Forem: Kamil Bugno

Zero Framework Overhead with Solid.js

Kamil Bugno — Tue, 16 Aug 2022 16:46:00 +0000

Would you like to learn about a new JavaScript Framework that boasts best in class performance metrics?

Parallel programming in C#

Kamil Bugno — Wed, 04 May 2022 09:15:16 +0000

Do you know what parallel programming is, how it differs from asynchronous programming and why it can enhance your application? If not, let's delve into this incredibly interesting topic.

What is parallel programming?

As the name suggests it means that certain pieces of code can run at the same time. Parallelism is something that you should even know from your everyday life. If this morning you prepared a coffee or a tea, probably you didn't wait until the water boiled to get the cup out of the cupboard. Most likely you did several things at once: you poured water into the kettle, turned it on, and while it was boiling you prepared a cup and poured in the right amount of coffee/tea. Thanks to it the process of preparing your morning drink was faster and you saved time.

If you want to translate the above situation into the programming world, we will use terms such as CPU and threads. Look at this picture:

As you can see, we have two CPUs, and some threads (black rectangular elements). At the same time, we do two operations: boil the water and prepare the cup. It is good to notice, that making a coffee/tea in a parallel way assumes that we use more than one available CPU to execute our tasks simultaneously.

It is easy to confuse parallelism with asynchronism because these things seem to be similar, but there is a huge difference between them - let's explore it.

Parallelism vs. asynchronism

Parallelism means that we can do two or more things at the same time, and you need at least two CPUs for that, while asynchronism can be achieved with one CPU and means that your threads don't actively wait for the end of some external operation. Also, async programming is used more frequently for some IO operations such as connecting to the database, access the file or call the API, whereas parallel programming is more focused of heavy CPU operations such as complex calculations. What is more, asynchronism can be achieved without parallelism: JavaScript is able to use asynchronous operations, but it is impossible to do some parallel stuff (since there is only a single-core). If you are interested in the details of asynchronous programming, read one of my posts that explains it.

Prons and cons of the parallel programming

Parallel programming is not something magical that always have only benefits for our application. Like most things it has its advantages and disadvantages. Let's take a look at them:
✅ As we mentioned earlier, parallelism can reduce the time of our operations because we are able to execute several actions at the same time.
✅ We can use our resources more efficient when we write a code with parallelism in mind.
❌ Parallel code is usually more complex to write, read, and debug.
❌ Parallelism has a strong connection to the hardware, there can be some differences in the execution of our code depending on the underlying hardware.

You should already understand the basic concept of parallelism, so let's go straight to how it can be achieved in C#.

Parallel programming in C#

Let's assume that we have several heavy computations that we would like to conduct. In our scenario, I prepared a special method for it:



public static int HeavyComputation(string name)
{
    Console.WriteLine("Start: " + name);
    var timer = new Stopwatch();
    timer.Start();
    var result = 0;
    for (var i = 0; i < 10_000_000; i++)
    {
        var a = ((i + 1_500) / (i + 30)) * (i + 10);
        result += (a % 10) - 120;
    }
    timer.Stop();
    Console.WriteLine("End: "+ name + ' ' + timer.ElapsedMilliseconds);
    return result;
}

The math operations simulate our heavy computation. Without the parallel programming, when we have several computation actions, we can run them in a sequence:



static void Main()
{
    var timer = new Stopwatch(); 
    timer.Start();
    HeavyComputation("A");
    HeavyComputation("B");
    HeavyComputation("C");
    HeavyComputation("D");
    HeavyComputation("E");
    timer.Stop();
    Console.WriteLine("All: " + timer.ElapsedMilliseconds);
}

The output is following:



Start: A
End: A 106
Start: B
End: B 106
Start: C
End: C 102
Start: D
End: D 110
Start: E
End: E 114
All: 575

Thanks to the example, we can see that All actions take similar or more time than the sum of the times of each action: All >= A + B + C + D + E.

Using `Parallel.Invoke` method

There is a way of improving the performance of it. We can simply use Task Parallel Library. Our HeavyComputation method remains unchanged, but we modify the way of calling it by using Parallel.Invoke:



static void Main()
{
    var timer = new Stopwatch(); 
    timer.Start();
    Parallel.Invoke(
        () => HeavyComputation("A"),
        () => HeavyComputation("B"),
        () => HeavyComputation("C"),
        () => HeavyComputation("D"),
        () => HeavyComputation("E")
    );
    timer.Stop();
    Console.WriteLine("All: " + timer.ElapsedMilliseconds);
}

The output is following:



Start: B
Start: A
Start: D
Start: C
Start: E
End: B 103
End: C 109
End: E 111
End: A 112
End: D 112
All: 200

Based on the input, there are several things that I would like to discuss:

time - as you can see, in the above example All operations take less time than the sum of each action: All < A + B + C + D + E. The conclusion is one - our computation tasks were run at the same time. It is important that Parallel.Invoke doesn't guarantee the parallel execution, because, as we mentioned earlier, it is dependent on other things such as hardware, but it enables your code to run at once.
order of operations - Parallel.Invoke doesn't provide the same execution order as we specified in the method, so this is the reason why our actions were executed in a different order.

It is also good to know that there are three more useful methods that can help us with executing our code in parallel:

Parallel.For
Parallel.ForEach
Parallel.ForEachAsync - it was added in .NET 6

Parallelism with asynchronism

Even though the parallel solution may seem to be correct, it can be improved even further, because it has one drawback: it is executed in a synchronous way. What exactly does it mean? I think that visual representation can clarify it:

our current solution (with some simplification) is the following The first CPU run the Main method and execute our computations (A-E) on separate CPUs. It is important that during the computations, the calling thread is actively waiting for the end of the execution of all computations.
in async way the picture will be as follows: During the heavy computation, the first CPU is free and can be used as needed.

How to write a code that will use parallel and asynchronism? The answer in not very complicated:



static async Task Main()
{
    var timer = new Stopwatch();
    timer.Start();
    await Task.Run(() =>
    {
        Parallel.Invoke(
            () => HeavyComputation("A"),
            () => HeavyComputation("B"),
            () => HeavyComputation("C"),
            () => HeavyComputation("D"),
            () => HeavyComputation("E"));
    });
    timer.Stop();
    Console.WriteLine("All: " + timer.ElapsedMilliseconds);
}

We just wrapped the Parallel.Invoke call inside Task.Run. Thanks to it we can use the await/async keywords and enhance the solution with asynchronous programming. Although everything looks fine now, there is still one thing to focus on: our computation returns some value, but so far, we haven't used it. Let's change that!

Save values from computations

In C# we have special collections designed for concurrent use. One of them is ConcurrentBag<T> that is thread-safe and can store unordered collection of objects. Our final solution will look like this:



static async Task Main()
{
    var timer = new Stopwatch();
    timer.Start();

    var myData = new ConcurrentBag<int>();

    await Task.Run(() =>
    {
        Parallel.Invoke(
            () => { myData.Add(HeavyComputation("A")); },
            () => { myData.Add(HeavyComputation("B")); },
            () => { myData.Add(HeavyComputation("C")); },
            () => { myData.Add(HeavyComputation("D")); },
            () => { myData.Add(HeavyComputation("E")); });
    });
    timer.Stop();
    Console.WriteLine("All: " + timer.ElapsedMilliseconds);

    Console.WriteLine(string.Join(",", myData));
}

We simply add new values to our ConcurrentBag collection and display it. Besides ConcurrentBag, there are more thread-safe entities that can store our data:

ConcurrentStack<T>
ConcurrentQueue<T>
ConcurrentDictionary<TKey,TValue>

It is good to know that from the performance perspective, there is one situation when they are slower than their nonconcurrent equivalent: when our solution doesn't use a lot of parallelism. So we have the most to gain from using them if our code is indeed heavily concurrent.

Exception handling

Let's modify our code to throw an exception at some point:



try
{
    await Task.Run(() =>
    {
        Parallel.Invoke(
            () => { myData.Add(HeavyComputation("A")); },
            () =>
            {
                Console.WriteLine("Starting B");
                throw new Exception("B");
                myData.Add(HeavyComputation("B"));
            },
            () => { myData.Add(HeavyComputation("C")); },
            () => { myData.Add(HeavyComputation("D")); },
            () => { myData.Add(HeavyComputation("E")); });
    });
}
catch (Exception e)
{
    Console.WriteLine("Exception: " + e);
}

I added try/catch block and raised an exception for B operation - all the rest remains unchanged. There are two things to keep in mind when it comes to exceptions:
a) When one parallel action raises an exception, it doesn't mean, that other operations will be stopped. They will continue their execution despite the fact of the exception. The output from the above code is the following:



Start: C
Start: A
Starting B
Start: E
Start: D
End: C 125
...

It shows that after the failure of B operation, the system still executed operation E and D. Taking this into consideration, you can assume that parallel operations are separated when it comes to the exception perspective.
b) When we catch the exception, you can see that we are dealing with AggregateException:

The AggregateException contain list of all exceptions throw by our parallel operations (in our case it is only 1) and the details of them (in our case it is "B"). It is important that thanks to AggregateException no exception will be lost, even when they will be raised at the same time.

There are two ineresting methods for handling AggregateException:

Flatten() - sometimes there is a need to have a parallel operation that run some nested parallel operations. As a name suggests, Flatten helps with converting all nested exceptions to one-level exceptions.
Handle() - it provides you with the ability to invoke a handler on each of your exceptions.

Let's see a full example that uses both Flatten() and Handle():



try
{
    await Task.Run(() =>
    {
        Parallel.Invoke(
            () => { myData.Add(HeavyComputation("A")); },
            () =>
            {
                //some nested operations
                Parallel.Invoke(
                        () =>
                        {
                            Console.WriteLine("Starting B1");
                            throw new InvalidTimeZoneException("B1");
                            myData.Add(HeavyComputation("B1"));
                        },
                        () => { myData.Add(HeavyComputation("B2")); },
                        () =>
                        {

                            Console.WriteLine("Starting B3");
                            throw new ArgumentNullException("B3");
                            myData.Add(HeavyComputation("B3"));
                        });
            },
            () => {
                Console.WriteLine("Starting C");
                throw new BadImageFormatException("C");
                myData.Add(HeavyComputation("C"));
            },
            () => { myData.Add(HeavyComputation("D")); },
            () => { myData.Add(HeavyComputation("E")); });
    });
}
catch (AggregateException e)
{
    e.Flatten().Handle(myException =>
    {
        var result = myException switch
        {
            InvalidTimeZoneException _ => HandleInvalidTimeZoneException(),
            ArgumentNullException _ => HandleArgumentNullException(),
            BadImageFormatException _ => HandleBadImageFormatException(),
            _ => false
        };
        return result;
    });
}

In the code above, we throw three types of exceptions: BadImageFormatException, ArgumentNullException, and InvalidTimeZoneException. Some of the parallel operations are nested, so in the catch block we use Flatten(). Using Handle helps us to deal independently with each of the exceptions. There are three helpers methods:



private static bool HandleInvalidTimeZoneException()
{
    Console.WriteLine("HandleInvalidTimeZoneException");
    //...
    return true;
}

private static bool HandleArgumentNullException()
{
    Console.WriteLine("HandleArgumentNullException");
    //...
    return true;
}

private static bool HandleBadImageFormatException()
{
    Console.WriteLine("HandleBadImageFormatException");
    //...
    return true;
}

Each of them handles the exact type of the exceptions and returns true. For Handle method value true means that the exception was handled correctly and should not be rethrown. This is the reason why we have this operation in the switch statement: _ => false - an exception that is not BadImageFormatException, ArgumentNullException, or InvalidTimeZoneException will be rethrown.

So far, our example was not complex. In real life scenarios, it may be different, and we will need some synchronization. Let's take a look at it.

Synchronization

Synchronization is a response to a situation when a lot of threads access the same data. Why might this situation be problematic? Let's assume that we want to perform some computation in parallel and store the sum of the results in a variable:



var finalResult = 0;

await Task.Run(() =>
{
    Parallel.For(0, 20, i => 
    { 
         finalResult += HeavyComputation(i.ToString()); 
    });
});

We used the Parallel.For method that is a loop whose iterations are executed at the same time. The first argument is the starting index (in our case 0), second is the final index (in our case 20) and third is an action that contains actual index (in our case i variable). Every parallel operation adds its result to the finalResult variable, and here is the issue: we end up with race condition.

What is race condition?

Race condition usually occurs when a lot of threads share the same data and want to modify them. Let's see how it can work in our case assuming that HeavyComputation returns value 10 all the time:

Thread X enters the line finalResult += HeavyComputation(i.ToString());. It checks the finalResult value and currently it is zero.
Thread Y enters the same line, checks the finalResult value that is 0, conduct the computations and modify the value to 10.
Thread X execute the computation and add ten to the value of finalResult. Because it checked the finalResult before it was modified by thread Y, the final value is ten instead of twenty.

Synchronization can deal with the race conditions by, among other things, using locks.

Locks

Locks are part of exclusive locking constructs. It means that only one thread can be in a section of the code that is protected by the lock. All other threads are blocked until the section is free and a new one can enter. Because of it, you should always lock a code that execute quickly to avoid bottlenecks. Let's see how it can be implemented in C#:



var finalResult = 0;
var syncRoot = new object();

await Task.Run(() =>
{
    Parallel.For(0, 20, i =>
    {
        var localResult = HeavyComputation(i.ToString());
        lock (syncRoot)
        {
            //one thread at the same time
            finalResult += localResult;
        }
    });
});

We used lock keyword that introduces the section where only one thread can be at the same time. As you can see, the section contains an operation of adding the value to finalResults - the computation is done before and, thanks to this, it can still be done in parallel. As we mentioned earlier, the code inside lock shouldn't be time consuming, because we will have a bottleneck and won't really use the power of parallelism.

One of the risks of using lock is dead lock. It is a situation when all threads are waiting (usually for each other) and the application cannot continue working. To avoid dead lock, it is good to have a separate syncRoot for every lock and minimizing the nesting of the locks.

It is worth mentioning that under the hood of lock we have a Monitor.Enter and Monitor.Exit operations. Let's see how the above code looks in Intermediate Language (IL):



//...
int num = HeavyComputation(i.ToString());
object obj = syncRoot;
bool lockTaken = false;
try
{
    Monitor.Enter(obj, ref lockTaken);
    finalResult += num;
}
finally
{
    if (lockTaken)
    {
        Monitor.Exit(obj);
    }
}

When we execute Monitor.Enter without any exception, the value of lockTaken will be changed to true. Later our code will be run (in this case finalResult += num;) and in the finally block we exit the monitor. finally section is extremely important because it protects us from the situation that our exception resulted in having a thread that enter the lock block but doesn't exit.

It is good to know that inside lock block we are not allowed to use async operations - otherwise you get an error: cannot await in the body of a lock statement. Why is there this limitation? Because from the thread perspective await keyword can create a new thread, but inside the lock only one thread is allowed.

Summary

In this post I tried to explain fundamentals of parallel computing: we learned why it is important, what are the advantages and disadvantages of parallelism and how to write correct concurrent code in C# using Task Parallel Library and locks. I hope that now you know all the essentials to start your journey into the parallelism!

Demystifying package.json

Kamil Bugno — Mon, 25 Apr 2022 11:15:27 +0000

If you work with a frontend, your project usually contains package.json file. Do you know what it's for and why this file is so important? Let's take a closer look at package.json.

In earlier times, when you met a representative of some company, you were likely to receive a business card. Small piece of paper contained all necessary information: name of the person, contact, company details, etc. File called package.json is something similar to a business card, but it describes your project. Let's see how the file can look.

{
  "name": "react-modal",
  "version": "3.15.1",
  "description": "Accessible modal dialog component for React.JS",
  "main": "./lib/index.js",
  "module": "./lib/index.js",
  "repository": {
    "type": "git",
    "url": "https://github.com/reactjs/react-modal.git"
  },
  "homepage": "https://github.com/reactjs/react-modal",
  "bugs": "https://github.com/reactjs/react-modal/issues",
  "directories": {
    "example": "examples"
  },
  "scripts": {
    ...
  },
  "authors": [
    "Ryan Florence"
  ],
  "license": "MIT",
  "devDependencies": {
    ...
  },
  "dependencies": {
    ...
  },
  "peerDependencies": {
    ...
  },
  "tags": [
    ...
  ],
  "keywords": [
    ...
  ],
  "engines": {
    "node": ">=8"
  }
}

The above file comes from react-modal, an open-source library. As you can see, it contains some data about the project (name, version, description, etc.) and lists all external projects that were used to build the library (devDependencies, dependencies, peerDependencies).

Dependencies

Currently, software projects aren't created in a vacuum. Otherwise, a development of new software would not be effective because you would need to reinvent the wheel repeatedly. In reality, most projects use previously developed solutions and build new user functionalities on top of them. This is called dependencies.

Versions of dependencies

Each dependency contains a name and a version: "react-dom": "^16.13.1". As you can see, the version is not just a number, but it has some characters. There is a special logic behind this and we will take a look at it:

16 - in our example, it is a major version. Usually, number that represent the major part is changed when incompatible or really big, new functionalities are added the project.
13 - it is a minor version. When small, new functionalities are added to the project, the minor version is usually incremented.
1 - it is a patch version. If the code contains some bugs, after the deployment of fixes, the patch number is changed.
^ - it means that only minor and path number can be increased. For example, "17.10.2" wouldn't comply this whereas "16.14.2" is ok and can be used by our project.

There are more options for special characters:

> - it means that all versions higher than the given can be used. For example, "17.10.2" is ok, but "15.11.3" isn't - the number is lower than our initial version "16.13.1".
~ - it means that only patch number can be increased. For example, "16.14.2" is not correct, because minor version is changed, but "16.13.2" is ok - the difference is only for the path part.
no character - it means that only the exact version is valid.

If you want to to play around with the versions, I recommend this site: https://semver.npmjs.com/

Installing dependencies

Let's assume that we have a package.json file and we want to run our project. One of the necessary actions that we need to take is to install all dependencies. It can be done by npm install. As a result, a new node_module folder will be created, and it will contain all packages from the section dependiencies of package.json. If your dependencies are dependent on other packages, they also will be downloaded and placed in node_module folder, even though they are not explicitly listed in your package.json - it is good to know that installing packages from dependencies section is transitive.

Sometimes when we use a lot of external packages, node_module folder can have an immense size. Because it is easy to recreate that folder (by installing the dependencies), you shouldn't include it to the repository - all team members are able to execute npm install to download necessary dependencies.

You can also notice that there is a new file added in your solution: package-lock.json. In the dependiencies section of that file, all dependant packages will be listed (even those that are indirectly dependent). I will explain package-lock.json more deeply later in this post.

Types of dependencies

In our example, react-modal has three types of dependencies: devDependencies, dependencies, and peerDependencies. Let's clarify the differences between them.

dependencies - as we mentioned earlier, all packages from dependencies section are installed along with its dependencies. If I want to install package X (as either dependencies or devDependencies) that has Y as dependencies, and Y has package Z as dependencies, all three packages (X, Y, and Z) will be installed and placed in node_modules. If you want to add a new package to your solution, you can use npm install NameOfThePackage.
devDependencies - while dependencies are transitive, devDependencies aren't. In the above example, when X is defined as dependencies or devDependencies in your project and both Y and Z packages are defined as devDependencies, they will not be added to the solution - only X will be downloaded. If you want to add a new package as a devDependencies to your solution, you can use npm install --save-dev NameOfThePackage. Development dependencies as a name suggest are helpful when it comes to develop the project locally. When it is deployed to the production, they are not useful and won't be added to node_module. So when you use a command npm install --production, and X is defined as devDependencies it won't be downloaded.

Given the above dependency classification, the question may arise of what type to use. There is a lot of opposite views on this topic, so I would like to discuss it more deeply. Let's assume that you want to build a React application and you used Create React App (CRA) tool for a configuration. When you open the package.json file, you can notice that there are only dependencies, not devDependencies:

...
"dependencies": {
    "@testing-library/jest-dom": "^5.16.4",
    "@testing-library/react": "^13.1.1",
    "@testing-library/user-event": "^13.5.0",
    "react": "^18.0.0",
    "react-dom": "^18.0.0",
    "react-scripts": "5.0.1",
    "web-vitals": "^2.1.4"
  }
...

Some of the Internet suggestions say that you should not use dependencies for packages that are focused on local development activities, such as testing libraries, code formatters, etc. But as you can see above, @testing-library/jest-dom that is helpful for writing tests is added as dependencies. To complicate matters further, when you visit, for example, prettier or eslint projects, you can see that on https://www.npmjs.com (official npm package repository) the instruction for installation is the following: npm i eslint. However, the eslint documentation says that you should use npm install eslint --save-dev. So, which one is better to use?
Before answering the question, let's separate the types of applications that you can build with the help of package.json file:

user applications: when you use, for example, React and your application is accessible for users by the browser, we can say that it is a user application.
developer application: when you build a piece of code that will be used by other developers, we can assume that you are working on a developer application. For example, react-modal is a developer application, because the main goal of it is to reuse its functionalities in external projects.

Having this distinction in mind, we can finally answer our question. When you build a developer application, you should add all packages which your app actively uses as an imported external functionality as dependencies. So, when you build a modal library that uses on its foundation react-modal, react-modal should be placed in dependencies section. But when you use prettier to format your code, you should download it as devDependencies. The above suggestions are valid when you build a developer application, for user applications there are some changes: it doesn't matter what type of dependencies you use. This is the reason why CRA placed all external packages in dependencies.

If you're observant, you probably noticed that we haven't discussed one type of dependencies yet: peerDependencies. I deliberately delayed explaining this because we need a distinction of application types which has just been introduced. peerDependencies are used for developer applications. Let's assume that our project uses package X and there is a high probability that other developers that will download our package also use X:

In that case, we can require a specific version of X package from developers who use our code. We can do it by writing: "X": "^2.14.0 in the peerDependencies section. As a result, the project that uses our package won't be able to download X with a lower version. If you, for example, tried to download X in "1.10.2" version you will receive the error:

Found: x@1.10.2
node_modules/x
   x@"1.10.2" from the root project
Could not resolve dependency:
peer x@"^2.14.0" from yourProject@1.0.0

Why do we need package-lock.json

As we mentioned earlier, when you run npm i you can see that package-lock.json file is added to your project. The main goal of this file is to store information about all dependencies and versions that your project uses. The file is able to contain nested dependencies (for example, our project is dependent on X, X on Y, and Y on Z - in package-lock.json all three dependencies, X, Y, and Z will be added). To understand why package-lock.json is so important take a look at the picture:

We have a project that has several dependencies. If you remember the version principles, you should know that, for example, Z package can have not only "7.8.9" version but also all versions with minor number increased. So, let's assume, that there is a release of a new version for Z package: "7.12.3". The same situation can be for our direct dependant: A package. When one user run npm i before a release of an updated version, the up-to-date version won't be installed. As a result, we can end up with a situation, when we use different versions of dependencies for our project (depending on when npm i took place):

Why might this situation be a problem? Let's assume that package A has a new functionality in version "10.23.8" that wasn't there before. Dorothy decided to use this new feature in a code and merged her changes to a repository. When Adam tried to run the code, there is an error - he used version "10.11.12". package-lock.json as a name suggests, lock all versions of used dependencies so that we are sure that the entire team will use the same version of external packages. It is important that package-lock.json should be included in our repository to use the power of locking dependencies' versions.

Scripts

Another thing that is specified in package.json file is a section called scripts. When you create a React application using CRA, you can see the following code:

 "scripts": {
    "start": "react-scripts start",
    "build": "react-scripts build",
    "test": "react-scripts test",
    "eject": "react-scripts eject"
  }

When you, for example, run npm start the command will be translated to react-scripts start because of the section scripts. There are a huge number of script's names that are supported by npm, but you are also free to specify your own names. Thanks to it, all team members that download your project with package.json file will be able to run the script with the custom name by using npm run CustomNameOfTheScript.

Summary

As you can see, one package.json contains many important things for your project. I hope that this post has made you more aware of the intricacies that may lie behind this file.

Asynchronous programming in C#

Kamil Bugno — Fri, 15 Apr 2022 10:16:52 +0000

Would you like to find out why asynchronous programming is important, how to use it in C#, and what advantages asynchronous code has? Let's get into it!

Why should we use asynchronous programming?

Most people who describe usage of asynchronism explain it by the example of a desktop app, so I will focus on this topic first.

Desktop app

Let's assume that we have a button called 'Process' in our desktop app, and when a user clicks it some computation that require access to external resources will take place (for example, API or database). If we don't use asynchronism, the entire app will be frozen during the processing time - our user won't be able to interact with the app. The different situation is with the power of asynchronous code. A main thread that is responsible for displaying the app view won't be blocked, and no frozen time will appear.

Let's visualize this situation in a detailed way:
1) On the left we have our desktop app. On the right there are details related to CPU and threads. When the app was rendering a view (UI) for the first time, a thread used some resources to do it (black rectangular element). Later, we can observe that there isn't any other action, and the app is idle. Nothing will happen until a user interact with the UI.

2) Let's imagine that the user clicked the button. The app started to be active and a thread was used to handle user interaction.

3) If you remember, we assumed that an action behind this button is to access external API or database. Let's see what will happen:

4) And here is the most crucial point: when we don't use asynchronous programming, our thread will be actively wait until the end of the API call. During this time, the application will be frozen, and the user won't be able to interact with it:

5) In an alternative situation with asynchronous programming, you can notice that during external call our CPU is free and the user can easily interact with the app without the frozen time.

The above situation was described for a desktop app, but let's be honest - this type is not as popular as it used to be. Currently, we usually create some web apps with a backend. So, what effect on it will asynchronous programming have?

Web server app

Let's assume that we have an API written in C#, and one of its endpoints accesses the database to retrieve some data. If we don't use asynchronous programming the thread will be waiting during the database retrieval operation. As a result, when a new request is come to our API, we couldn't process it effectively. To make matters worse, our system can create some additional threads in the background to handle new requests. Why this situation is not good? Because creating new threads is consuming, and when the CPU is busy with our first request, newly created threads won't be scheduled and unfortunately, they will be waiting.

Let's observe this situation on the images:
1) At the beginning we see that a thread was used. The main goal for it was to start the web server, do some start up operations, etc. After that, the server is idle because there aren't any user requests:

2) Our API received one HTTP request. A thread will take care of handling this request:

3) During that request we want to get some data from external resource. When we reach the C# code responsible for retrieving data from the database, the situation will be the following:

4) Without asynchronism we end up with the thread that will do nothing except for waiting for the database query's result. New requests cannot be easily processed.

5) With asynchronous programming we will have a free CPU that can handle new requests, so our API is more effective - it can process more requests than in the previous situation.

The web server explanation assumed that we had only one CPU, because I want to keep it as simple as possible, but the situation with several CPU will be quite similar.

Currently, you should know what the benefits of asynchronous programming are. Let's see how we can use it in C#.

Async and await

If we want to use the power of asynchronism, we can easily do it in C# by two keywords: async and await. It is good to know that there are some rules related with these words - let's dig into this.

1. Method that uses await should be async

If we assume that we want to make some HTTP request, we can do it in that way:



public async Task DoSth()
{
     var client = new HttpClient();
     var result = await client.GetAsync("https://www.kamilbugno.com");
     //...
}

Please note that GetAsync is an asynchronous method and thus should be called with an await keyword. Every method that uses await must be marked as async. Without having async in the method declaration, we will receive an error and the code won't compile correctly.

2. It is possible to run async operation without await

The following code will compile even if there is no await keyword:



public async Task DoSth()
{
     var client = new HttpClient();
     var result = client.GetAsync("https://www.kamilbugno.com");
     //...
}

What is more, we can also remove the async word, because there is no await usage in the body of the method. This process is called 'Eliding async and await'. It is good to know, that it has some big consequences and is only recommended in a special situation.

Consequences

The code will simply continue working without taking care of the async operation. It may seem to be an advantage, but there are some issues related to it:

using statement: if our code is in a using statement, the object can be disposed before the operation ends, and, as a result, the operation won't succeed.
try/catch block: it may happen that the execution reached the end of try/catch block before the operation ends, and, as a result, we will not be able to properly handle the exception.
using 'Eliding async and await' incorrectly can even cause a termination of the entire process.

Use Case

Let's assume that we have two nested methods A and B (B is called inside A and contains some async operations). Both methods A and B use async/await word. In that scenario, we can skip async/await in the inner method (B) because it will be eventually awaited in A method. This is the only situation, when considering 'Eliding async and await' might be a good idea.

Example:



public async Task A()
{
    var result = await B();
    //...
}

public Task<HttpResponseMessage> B()
{
    var client = new HttpClient();
    return client.GetAsync("https://www.kamilbugno.com");
}

3. Async method can return `Task`, `Task<T>`, `ValueTask<T>`, or be `void`

The async method can return several types, and now we will focus on the most common ones:

a) `Task` vs `void`

Task is usually used when we don't want to return any real value. Why don't use void? It is true that in non-asynchronous world in this scenario we will use void without a second thought, but in async code it is not valid anymore. Task object contains some additional information about the operation and can be awaitable, so this is the reason why most often you will see Task instead of void. What is more, it is impossible to use await word to call async method that returns void.

b) `Task<T>` vs `ValueTask<T>`

When we want to return some value, we have two options Task<T> and ValueTask<T>. What is the difference? The former is a reference type whereas the latter is a value type. ValueTask<T> is in some cases better when it comes to the performance than Task<T>. There is one special scenario for using it: when the execution path can retrieve data in both synchronous and asynchronous way. Sounds complicated? Let's see an example:



public async ValueTask<int> GetPageVersion()
{
     if (_cachedValue == null)
     {
         var client = new HttpClient();
         var result = await client.GetAsync("https://www.kamilbugno.com");
         _cachedValue = result.Version.Build;
     }    
     return _cachedValue.Value;     
}

As you can see, the method GetPageVersion behaves differently based on the cached value. It is likely that most of the time, the asynchronous code will not be run. In that case ValueTask<T> is a better choice. In any other scenarios you should consider Task<T>.

4. Async method can be called in a sync way

It is quite important to be able to distinguish a situation when we have a synchronous and asynchronous code.
Let's see an example:



public int GetPageVersion()
{
     var client = new HttpClient();
     var result = client.GetAsync("https://www.kamilbugno.com").GetAwaiter().GetResult();
     return result.Version.Build;
}

We run client.GetAsync method, and as a name suggest, it is asynchronous method. But the way of calling this method matters: when we use GetAwaiter and GetResult the code will be executed synchronously. It is good to know that using it can be dangerous - we can even end up with deadlocks.

Now, you should know the basics of using async and await in your C# code. But do we really know how it works? Let's explore this topic more deeply.

Under the hood of asynchronism

To be able to go under the hood we will need some Intermediate Language (IL) viewer. When we build the project, the .NET environment generates IL code from our source code and thanks to it we can really see what is going here.

Let's assume that we have a simple class with an empty method. The IL code for it will be the following:

It isn't very readable, but we can see that in some way it is similar to original method, isn't it? But what will happen when we add async word to the method declaration?

As you can see, IL code is completely different. Instead of having a method DoSth, we currently have a class. Why? Because async/await words are using a state machine. If you take a close look at the IL code, you can see that DoSth implements interface IAsyncStateMachine, contains property state, and has method MoveNext.

How does state machine work?

It is important that state machine is not an entity that exists only in C# world, or that is related only to asynchronism. State machine is an implementation of the state design pattern, and you can create your own state machine. It can behave differently depending on its internal state. Sounds confusing? Let's imagine that we have following state machine.

We can be hungry or full - these are the states that our machine has. As you may have guessed, we aren't usually all the time hungry or full, during the day it is possible to change the state. By eating pizza, you can move from hungry to full state, and by going swimming your state can reach hungry.

Analogous situation we have in C# when it comes to asynchronous programming. The previously mentioned MoveNext method is responsible for changing the state of the machine and do some actions.

Let's assume that we have the simple async method:



public async Task<string> DoSth()
{
     Console.WriteLine("one");
     var client = new HttpClient();
     var result = await client.GetStringAsync("https://www.kamilbugno.com");
     Console.WriteLine("two");
     return result;
}

The method MoveNext that is generated for this code can look similar to this:



private void MoveNext()
{
    int num = this.state;
    string result;
    try
    {
        TaskAwaiter<string> awaiter;
        if (num != 0)
        {
            Console.WriteLine("one");
            client = new HttpClient();
            awaiter = client.GetStringAsync("https://www.kamilbugno.com").GetAwaiter();
            if (!awaiter.IsCompleted)
            {
                num = (state = 0);
                this.taskAwaiter = awaiter;
                this.stateMachine = this;
                this.asyncTaskMethodBuilder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine);
                return;
            }
        }
        else
        {
            awaiter = this.taskAwaiter;
            this.taskAwaiter = default(TaskAwaiter<string>);
            num = (state = -1);
        }
        this.myString = awaiter.GetResult();
        this.result = this.myString;
        this.myString = null;
        Console.WriteLine("two");
        result = this.result;
    }
    catch (Exception exception)
    {
        state = -2;
        client = null;
        this.result = null;
        this.builder.SetException(exception);
        return;
    }
    state = -2;
    this.client = null;
    this.result = null;
    this.builder.SetResult(result);
}

I changed some variable names to make it more readable. The flow of this state machine is the following:
1) At the beginning we have this.state set to -1.
2) MoveNext method is called. Because of the state value the if statement is true, so we execute this piece of code:



Console.WriteLine("one");
client = new HttpClient();
awaiter = client.GetStringAsync("https://www.kamilbugno.com").GetAwaiter();

Let's assume that the awaiter is not completed so we set the state to 0 and exit the method:



num = (state = 0); 
this.taskAwaiter = awaiter; 
this.stateMachine = this;
this.asyncTaskMethodBuilder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine);
return;

3) MoveNext method is called again. The else block will be executed because the current machine state is 0:



awaiter = this.taskAwaiter; 
this.taskAwaiter = default(TaskAwaiter<string>); 
num = (state = -1);

As a result, the state will be set temporarily to -1. Later the following piece of code will be run:



this.myString = awaiter.GetResult();
this.result = this.myString;
this.myString = null;
Console.WriteLine("two");
result = this.result;

Finally, the last piece of code will be executed:



state = -2;
this.client = null;
this.result = null;
this.builder.SetResult(result);

4) The machine is in state -2, and we received the result of our operation.

The above example shows state machine that was generated by a source code containing only one await keyword. When we use await more than once in the given method, the state machine ends up with more complicated MoveNext version. If you would like to experiment with it, I recommend https://sharplab.io/ for viewing Intermediate Language or a downloadable tool ILSpy which has similar functionality.

So far we have learned what a state machine is and how it helps us with asynchronism, but we still have one mystery left to unravel: who calls MoveNext method?

Thread pool

Thread pool is an extremely important entity that takes care of managing the threads. Thanks to it, we don't need to worry about creating a new thread or reusing existing one - thread pool is responsible for that.

One part of thread pool is a queue that stores free threads.

Since creating a new thread is costly, thread pool monitors all threads and when one of them in no longer used, it is moved to the queue. As soon as our application needs additional thread, thread pool checks if there are free threads to schedule, and only if there are no threads in the queue, a new one is created. We already know the basics of thread pool, so let's get back to our state machine and MoveNext method.

From Thread Pool's perspective, what will the execution of the following program approximately look like?



public async Task<string> DoSth()
{
     var client = new HttpClient();
     var result = await client.GetStringAsync("https://www.kamilbugno.com");
     return result;
}

Given some simplification, the way how thread pool helps us with the execution is not very complicated:

State machine will be created, and thread pool will schedule the call to the Internet by running MoveNext method (a new/different thread can be used to do it),
The web request was sent, and we are waiting for response...
Thread pool is notified by external entity such as a network driver that the web request completed, and it runs MoveNext method again (a new/different thread can be used to do it).
We receive the result of our operation and DoSth method is completed.

By now you should know all the necessary things to consciously use the power of asynchronism in C#.

Summary

As you can see, asynchronous programming can help you to create more effective application and to use the available resources (such as CPU, memory, etc.) better. I hope this post enriched your knowledge about asynchronism and currently, you will be able to easily write asynchronous code.

You can also read this post on my official blog: https://blog.kamilbugno.com/

Availability in Azure

Kamil Bugno — Wed, 09 Mar 2022 07:14:51 +0000

Sometimes we observe a downtime of popular websites because of a cloud provider's outage. The fact that we use a cloud doesn't automatically guarantee high availability of our application - there is a shared responsibility between cloud providers and its clients. Let's learn how we can use the power of cloud to make sure that our Azure resources are high available.

How much money can the company lose due to the outage?

Are you wondering how much can the outage cost? For the most popular services, the loss of money is likely to be mind-boggling - for example, YouTube was down for 37 minutes in 2020 and it resulted in losses of $1.7 million [1]. In 2013 Amazon.com had a downtime and each minute of the outage costed them about $66,240 [2]. These enormous numbers show that high availability is an important topic and can have a critical impact on the company's finances, so let's delve into it.

How to protect our application from downtime?

Imagine that we have a business-critical application hosted on virtual machine. There are several ways how we can reduce the risk of outage.

No protection

The starting point is to have a single virtual machine. Users can access the application by sending requests directly to HTTP/S port of the VM and in this way interact with our application.

As long as the virtual machine works correctly our application is available. This is not a recommend solution because each downtime of our single VM will result in situation where our users won't be able to access the application. Let's see how we can improve it.

Isolated hardware redundancy

To help us protect the virtual machines, Azure introduced special entities called fault and update domains. Let's take a look at them:

fault domain - it is a set of virtual machines that use the same power and network infrastructure. When there will be a power, network or hardware issue, all virtual machines in that domain will be affected.
update domain - it is a set of virtual machines that can be updated and rebooted at the same time. Azure ensures that two virtual machines that are in a separate update domain will not be affected at the same time, when maintenance activities will be required.

As a result, we can use the power of the fault and update domains and deploy two virtual machines - each in a separate domain. It can be done by using an availability set:

All you need to do is to create two virtual machines and during the creation add them to the availability set. After it you can check that the virtual machines are placed in a different update and fault domain:

There is also one important fact - we need a special service that will be responsible for balance the traffic to our virtual machines. We can use Azure Load Balancer for it and configure backend pool to contain our virtual machines. The architecture of that solution is the following:

This solution helps us to provide higher availability, but it has its limits. For example, when the whole data center will be down, our application still will be impacted. For that scenario, we will need more protection.

Availability zone redundancy

It is good to know that Azure has in almost every region three separate data centers. What is more, there is a rule that each of the data centers should be in a distance of at least 16 km. Thanks to it, when some natural disaster occurs, it is more likely that not all the data centers will be impacted. During the creation of the VM we can select the availability zone and add virtual machines to a separate zone. We still need a load balancer to handle the traffic and it can be configured for our virtual machines:

Thanks to it, when one of the data center will be down, load balancer will send traffic to the second virtual machine in a different availability zone (AZ).

This solution can fulfill the most common availability requirements, but what if we need a higher protection?

Region redundancy

To achieve region redundancy, some more steps are required. It is important that currently there is no load balancer in general availability (GA) that supports sending traffic across several regions. For that scenario we need to use a different service. One of the options is Traffic Manager. We can configure Traffic Manager to send requests to our virtual machines placed in different regions:

During the creation of the Traffic Manager, we are required to select a routing method:

Let's take a look at some of these values:

priority - it is used to configure primary, secondary, and so on resources to which the traffic will be redirected. For example, we want to send users' requests to the first VM and only when the VM is unavailable the requests should be transferred to the second VM. In that case, the first VM should receive priority 1 and the second the priority 2:
performance - it gives the opportunity to use not only the power of availability but also improve the performance. Your users will be redirected to resources which are the closest for them from the network latency point of view. It is determined by using the source IP address that is related to the recursive DNS service.
weighted - you can distribute the traffic based on the weight. For example, when there is a need to balance the traffic equally between two VMs, you should assign the same weight (in our case the value is 50): This routing method can also be used for blue-green deployments. Let's assume that we have an updated version of our application, and we want to provide it gradually to the users. We can configure that only 20% of our users will be able to use the new version - when it turns out that there are no issues related with the newly added functionality, we can make the latest version available for more users.

So far, we discussed having only two virtual machines. Let's be clear, in a real-life scenario we will usually use much more virtual machines - that brings us to a solution when we use both Traffic Manager and Load balancer with multiple virtual machines:

Availability with scalability

The above architecture is great when it comes to high availability, but from the scalability point of view it can be improved. Let's assume, that our application has a varied user traffic - at some point a vast number of users visit our application, but there are also periods of lower traffic. In that case, the best option is to use virtual machine scale sets (VMSS). VMSS is responsible for horizontal scaling - when the traffic is huge, it can automatically deploy new virtual machines, and when the traffic is decreased, number of virtual machines can be reduced. So the final solution can look like this:

Availability is a huge topic

In this post I tried to focus only on virtual machines and load balancer/traffic manager. It is good to remember that this topic is very wide and there are some other important challenges:

availability of data (CosmosDB, Azure SQL Database, storage accounts, etc.)
balance the traffic (Application Gateway, Azure Front Door, etc.)
data backup and recovery (Azure Site Recovery, Azure Backup, etc.)
more and more...

As you can see, there are a lot of areas to learn about availability - you can treat this post as a small introduction and I hope that it will encourage you to explore this topic deeper.

References:
[1] https://www.foxbusiness.com/technology/google-lost-ad-revenue-during-youtube-outage-expert
[2] https://www.forbes.com/sites/kellyclay/2013/08/19/amazon-com-goes-down-loses-66240-per-minute/?sh=5ebfbeae495c

You can also read this post on my official blog: https://blog.kamilbugno.com/

Driving a robot with a neural network [free meetup online]

Kamil Bugno — Tue, 25 Jan 2022 13:02:52 +0000

Have you ever wondered what it takes to drive a robot with a neural network? Take part in a free online meetup:

https://www.meetup.com/TWF-Meetup/events/283478382/

RxJS in Angular: from beginner to advanced beginner

Kamil Bugno — Thu, 28 Oct 2021 12:58:16 +0000

View it on YouTube: RxJS in Angular: from beginner to advanced beginner

Dependency injection in .NET Core

Kamil Bugno — Mon, 20 Sep 2021 09:32:50 +0000

You can also read this post on my blog: blog.kamilbugno.com

Have you ever wondered what DI has to do with sushi, why DI is important and how to achieve it in .NET Core? If yes, this article is for you!

DI and sushi

I love sushi. Dipping into soy sauce with a bit of Wasabi paste make sushi delicious 🍽

But what does this have to do with DI?

Let's assume, that I want to prepare sushi on my own. Doing it in C# (haha) might look something like this:

public class SushiService
{
    public Sushi DoSushi()
    {
        var whiteRice = GetWhiteRice();
        var pot = GetPot();
        var boiledRice = pot.Boil(whiteRice);
        var smokedSalmon = GetSmokedSalmon();
        var seaweedSheets = GetSeaweedSheets();

        //some other steps
        //...

        return sushi;
    }

    private SmokedSalmon GetSmokedSalmon() { ... }

    private SeaweedSheets GetSeaweedSheets() { ... }

    private Pot GetPot() { ... }

    private WhiteRice GetWhiteRice() { ... }
}

Why is it not a good idea to prepare sushi without DI?

It can seem correctly, but there are several drawbacks of this solution. For example, the above code assumes, that we can use only one, specific pot. Despite the fact, that in my cupboard there are a lot of pots and all of them can be used to boil something, I don't have sufficient freedom to choose them. What is more, if I have already boiled rice (because I prepared too much for a previous meal), I cannot use it for my sushi - sushi method requires to prepare new rice. Analogous situation is for ingredients, I can have multiple seaweed sheets or smoked salmons (one in the fridge, another in the freezer, etc.), but I am able to use only one of them no matter how many times and when I will be making sushi. As you can see, it is not the best way of preparing sushi.

Sushi with DI is delicious

Don't worry, you don't have to be hungry - we can simply refactor our solution and with the power of dependency injection prepare delicious sushi.

The first step is to create abstraction that is responsible for certain steps of preparing sushi.

public class SushiService
{
    private IRiceRepository _riceRepository;
    private ISalmonRepository _salmonRepository;
    private ISeaweedSheetsRepository _seaweedSheetsRepository;
    private IPotRepository _potRepository;

    public SushiService(IRiceRepository riceRepository, 
                        ISalmonRepository salmonRepository,
                        ISeaweedSheetsRepository seaweedSheetsRepository, 
                        IPotRepository potRepository)
    {
        _riceRepository = riceRepository;
        _salmonRepository = salmonRepository;
        _seaweedSheetsRepository = seaweedSheetsRepository;
        _potRepository = potRepository;
    }

    public Sushi DoSushi()
    {
        var whiteRice = _riceRepository.GetRice();
        var pot = _potRepository.GetPot();
        var boiledRice = pot.Boil(whiteRice);
        var smokedSalmon = _salmonRepository.GetSmokedSalmon();
        var seaweedSheets = _seaweedSheetsRepository.GetSeaweedSheets();

        //some other steps
        //...

        return sushi;
    }
 }

Advanteges of DI

As a result, our sushi is not dependent on the exact source of salmon or pot instance. It uses repositories to retrieve the desired objects without knowing about the details. From the SushiService perspective it doesn't matter what exact pot we use and how to obtain it - from now on these considerations belong to IPotRepository.

We can also modify the way of getting boiled rice. Since we use only boiled rice, we can create another piece of abstraction, that is responsible for providing SushiService with boiled rice:

 public class SushiService
 {
     private IRiceService _riceService;
     private ISalmonRepository _salmonRepository;
     private ISeaweedSheetsRepository _seaweedSheetsRepository;
     public SushiService(IRiceService riceService, 
                         ISalmonRepository salmonRepository, 
                         ISeaweedSheetsRepository seaweedSheetsRepository)
     {
         _riceService = riceService;
         _salmonRepository = salmonRepository;
         _seaweedSheetsRepository = seaweedSheetsRepository;
     }

     public Sushi DoSushi()
     {
         var boiledRice = _riceService.GetBoiledRice();
         var smokedSalmon = _salmonRepository.GetSmokedSalmon();
         var seaweedSheets = _seaweedSheetsRepository.GetSeaweedSheets();

         //some other steps
         //...

         return sushi;
     }
 }

So, we don't have to worry about the process of boiling our rice and what piece of equipment we need to use for boiling. All of it is done by IRiceService. The advantage of this solution is the fact, that we can reuse our IRiceService in different situations. You don't have to write the same piece of code every time when you want to use boiled rice:

 //...
 var whiteRice = _riceRepository.GetRice();
 var pot = _potRepository.GetPot();
 var boiledRice = pot.Boil(whiteRice);
 //...

Instead, you can simply call GetBoiledRice from IRiceService. Thanks to this, when the method of preparing boiled rice change, you will modify only one place - RiceService.

It is also good to know that next benefit of using DI is the testability aspect. Let's imagine that ISalmonRepository sends HTTP request to order salmon online and it will be shipped to your house. It will be a waste of money to buy salmon each time when you want to check if your method of preparing sushi works. For example, you can ASSUME that you have the salmon and use this assumption when you verify other steps. This is the way how we can do it in C# for all dependencies:

 [Fact]
 public void VerifySushiMethod()
 {
     //Arrange
     var riceServiceMock = new Mock<IRiceService>();
     var salmonRepositoryMock = new Mock<ISalmonRepository>();
     var seaweedSheetsRepositoryMock = new Mock<ISeaweedSheetsRepository>();
     //...
     var sushiService = new SushiService(riceServiceMock.Object,
                salmonRepositoryMock.Object,
                seaweedSheetsRepositoryMock.Object);

     //Act
     var sushi = sushiService.DoSushi();

     //Assert
     //...
  }

DI in .NET Core

The last step that is required to complete the process is to inject the dependencies. In .NET Core there is a built-in container that help you to use DI. In Startup class there is ConfigureServices method that you can use to specify the dependencies:

  public void ConfigureServices(IServiceCollection services)
  {
       //...
       services.AddTransient<IRiceService, RiceService>();
       services.AddTransient<ISeaweedSheetsRepository, SeaweedSheetsRepository>(); 
       services.AddTransient<ISalmonRepository, SalmonRepository>();
       //...
  }

.NET Core provides you with the option to control the lifetime of injected services. There are three types to choose from:

AddSingleton - it creates one object that will be reused for all requests.
AddTransient - it creates an object each time when it is requested from the code, so the new instance is provided to every class that use the specified interface.
AddScoped - it creates the object for each client request, so the object will be different across different client requests.

Summary

To sum up, using DI is extremely useful because it makes your code more readable, testable, and flexible. As you can see, it is not hard to write a piece of code that use the power of dependency injection. I might even risk saying that it's easier to implement it in C# than making real sushi yourself.

Revision questions for AI-102

Kamil Bugno — Fri, 18 Jun 2021 09:33:15 +0000

You can also read this post on my blog: blog.kamilbugno.com

Would you like to revise your knowledge before the exam? During preparation to AI-102 I made lots of notes, and I decided to share them with you. This article doesn't cover all topics required for AI-102, but I believe it can be a great resource to structure your knowledge. Let's start go deeper into the AI-102 world!

What are Cognitive Services?

It is sometimes called an 'umbrella' service because it contains other AI services such as Face, LUIS, Speech to Text, etc. All the contained services can be used independently - you can search them in Azure Marketplace and add them to your solution. So why do we need Cognitive Services? It is more comfortable to use it when we know that we need several different services related to AI and thanks to Cognitive Services, we don't have to add each of the services separately. There is also a difference in a free tier: Cognitive Services don't have free tier options. On the contrary, other AI services such as Computer Vision and Face provide you with free tier options.

Can I use Cognitive Services as a container?

Yes, you can. Thanks to it, you can use AI functionalities on-premises. There are two vital facts related to it: not all AI services support containerization (for example, Face), and you must send metering data to Azure because of the billing process (Azure needs to know how you use its services to be able to prepare a bill for you).

What are the benefits of having Cognitive Services as a container?

You have the possibility of controlling your data. By using containers, you don't have to send your data to the cloud to use AI services - all the work is done on-premises. What is more, you can use the advantages of containers: portable application architecture and scalability achieved by using orchestration tools such as Kubernetes.

What is Computer Vision API?

It enables you to analyse content in both images and video. You can use either REST API or client library (for C#, Python, Java, etc.) There are several crucial functions, that this API provides - below there are methods that you can use in Python:

computervision_client.describe_image - generate a human-readable sentence that describes the image,
computervision_client.tag_image - returns tags based on recognizable objects, living beings, scenery, and actions,
computervision_client.analyze_image - returns object that contains several properties:
- brands.name - detects corporate brands and logos in the image,
- adult.is_adult_content - returns true if the image show nudity and sexual acts,
- adult.is_racy_content - returns true of the image is sexually suggestive.
computervision_client.analyze_image_by_domain("celebrities", image_url) - recognizes celebrities,
computervision_client.analyze_image_by_domain("landmarks", image_url) - detects landmarks in the image.
computervision_client.generate_thumbnail(width, height, image_url) - creates reduced-size representation of an image. It can change the aspect ratio and remove distracting elements from the image.
computervision_client.read(image_text_url, raw=True) uses Read API to return (in an async way) object that contains result.analyze_result.read_results - it provides you with the extracted printed or handwritten text from an image. Read API supports files in JPEG, PNG, BMP, PDF, and TIFF formats.

What is Form Recognizer?

Form Recognizer is a part of Computer Vision, and you can use it to extract key-value pairs and table data from form documents. It contains several methods:

form_recognizer_client.begin_recognize_content_from_url(form_url) - it returns a collection of objects: one for each page in the submitted document. You can access cells and texts from the returned objects,
form_recognizer_client.begin_recognize_receipts_from_url(receipt_url) - it extracts common fields from US receipts by using a pre-trained receipt model,
form_recognizer_client.begin_recognize_business_cards_from_url(business_cards_url) - it extracts common fields from English business cards by using a pre-trained model.

How can I detect faces on images?

You have two possibilities: you can run Computer Vision method: computervision_client.analyze_image(image_url, ["faces"]) or you can use Face API. It is important to know the difference between them. Computer Vision's analyze_image method only provides a subset of the Face service functionality, so you are not able to use more advanced solutions with it.

What is Face API?

It provides you with AI algorithms related to human faces. This service contains five main functionality:

face detection - it simply detects faces and returns the rectangle coordinates of their locations. You can use face_client.face.detect_with_url method in Python to fulfil the detection.
face verification - it helps to answer the following question: "Are these two images the same person?". You can use face_client.face.verify_face_to_face for it.
face identification - it helps to answer the following question: "Can this detected face be matched to any enrolled face in a database?". You can use face_client.face.identify method for identification,
find similar faces - let's imagine that we have a target face and a set of candidate faces. The goal of this feature is to find a smaller set of faces (from candidate faces) that look like the target face. You can use face_client.face.find_similar method for this,
face grouping - it divides faces into several groups based on similarity. From the code perspective it is a bit more complicated than the methods above. Firstly, you have to create group (face_client.person_group.create), secondly, you need to define one or more person in that group (face_client.person_group_person.create), later you should add images of the newly created person (face_client.person_group_person.add_face_from_stream), penultimate step is to train the model (face_client.person_group.train) and finally you can identify the person from the group (face_client.face.identify).

What is Custom Vision?

The main goal of Custom Vision is to create custom image identifiers. You can train the model to serve your individual needs. Let's imagine that you want to have a service that distinguish cat from dog. You upload several images of cats with 'cat' labels and do the same for dog. After training, you are able to upload a new image, that the model hasn't seen yet, and you will receive information if the image shows cat or dog with the great accuracy.

It is also good to know that Custom Vision has two main features:

image classification - it applies labels to an image,
object detection - it not only add labels, but it also returns the coordinates of the labelled object location. It is important to remember that you have to add labels and coordinates for training data on your own.

How can I use Custom Vision?

You have three options:

online site (https://www.customvision.ai/),
SDK that support C#, Python, etc.,
REST API.

Each option provides you with the same type of AI functionality.

What is Video Indexer?

It is an AI service that provides you with the possibility of extracting information from video. It is focus on both visual and audio aspect of the video.

The functionality is really impressive and includes:

face detection - it detects faces that are visible on the video,
celebrity identification,
visual text recognition - it extracts text from the video frame,
visual content moderation - it informs you if the adult content is displayed on the video,
scene segmentation - it determines when a scene is changed on the video,
rolling credits - it identifies when rolling credits are displayed,
audio transcription,
noise reduction,
speaker enumeration - it can understand which speaker spoke which words and when. It is good to know that only sixteen different speakers can be detected in a single audio-file.
emotion detection - identifies emotions based on speech (joy, sadness, anger, ect.),
keywords extraction - it extracts keywords from speech and visual text.

How can I use Video Indexer?

You have two options: online site (https://www.videoindexer.ai) and API.

Can I customise Video Indexer?

Yes, to some extend you can. For example, if some faces are detected on your video and they are not celebrities they will be left unnamed. You can describe unrecognized faces, and as a result, your newly labelled faces will be saved in the model. So, from that point Video Indexer will be able to recognize these faces. Similar case is for brands. You can customize brands model to exclude certain brands from being detected or include brands that should be part of your model but weren't detected. What is more, you can also customize language model for example to be able to know that you don't want to translate 'Kubernetes' word, because it is from a technical domain.

What is Text Analytics API?

Text Analytics API a part of Language APIs and it is focused on Natural Language Processing. The functionalities that Text Analytics provides are:

sentiment analysis - it can determine if the document/sentence is positive, negative, or neutral,
key phrase extraction - it returns a list of key phrases,
language detection - you can send a text in some language and the response will contain the name of used language and the confidence score,
named entity recognition - it can recognize some entities in the text (for example people, places, organizations, etc.).

How can I use Text Analytics API?

You can use either SDKs (for C#, Python, etc.) or REST API. For example, in C# there is a method textAnalyticsClient.AnalyzeSentiment(document) for sentiment analysis or you can use REST API - /text/analytics/v3.0/sentiment endpoint will return the same data as the SDK's method.

How many languages are supported for Text Analytics?

Each functionality has a separate supported languages list. For example, key phrase extraction supports both English and Polish (and many more), but as for sentiment analytics Polish is not supported.

What is the Speech service?

As a name suggests, it is focused on the speech. These are the provided functionalities:

Speech-to-Text,
Text-to-Speech,
Speech-to-Speech translation,
Speech-to-Text translation.

It is important that both Speech-to-Speech and Speech-to-Text translation are supported only for SDK - there is no REST API for them.

Can I customize Speech service?

Yes, you can create a custom model for Speech-to-Text functionality by using Custom Speech service, and for Text-to-Speech by using Custom Voice service.

What is Language Understanding (LUIS)?

It is a conversational AI service. You can use it to understand users needs. Let's image a chatbot or voice assistant that should increase the productivity of the employees. When the user writes/says 'I want to send email to Tom', LUIS will use trained model to predict the meaning of user input - as a result, SendEmail method will be executed with EmailTo property set to Tom.

How can I use LUIS?

You have three options:

dedicated website (https://www.luis.ai/);
REST API;
SDKs (C#, Python, etc. are supported).

What are utterances?

Utterances are the user input. In the above example, we use the following text 'I want to send email to Tom' - it is the utterance.

What is intent?

Intent is an action that the user wants to perform. In the above example 'SendEmail' is the intent. LUIS determines intent based on user input (utterances).

What is entity in LUIS?

Some actions can require attributes. LUIS is able to recognize the entities from utterances. For example, {"EmailTo": "Tom"} is an entity retrieved from the sentence 'I want to send email to Tom'.

What should I do to start using LUIS?

Add Microsoft.CognitiveServices to your Resource providers:
Create Cognitive Services account:
Create app:
Build your language models by specifying intents and entities - you can use prebuild data. For example, when you select Email.SendEmail intend then a lot of utterances is automatically added: Entities can also be predefined:
Train the model:
Publish to endpoint;
Test from endpoint.

What is Azure Cognitive Search Service?

As a name suggests, this service enable you to use search functionality on your data. For example, you can search all data that are stored Azure SQL Database or Azure Cosmos DB.

What is the difference between index and indexer?

Indexer can crawl your data source and create an index. The index is a collection of documents that can be searched. Index can contains additional data that specify how the search functionality is used on it, such as: sortable (true | false), filterable (true | false), searchable (true | false), etc.

How can I create an indexer?

All indexers are required to contain:

name - the name of the indexer;
dataSourceName - you can choose from:
- SQL Managed Instance
- SQL Server on Azure Virtual Machines
- Azure SQL Database
- Azure Table Storage
- Azure Blob Storage
- Azure Cosmos DB
- Azure Data Lake Storage Gen2
targetIndexName - the name of your index.

From the technical point of view, you can create indexer using Azure portal, REST API, SDKs (.NET, Java, Python and JavaScript are supported).

How can I run indexers?

You can run indexers after the creation, so it will retrieve desired data from the source and put it to index. As a result, they will be available for the search functionality. But what about the situation when data is changing all the time, and you want to search up-to-date data? In that case, you can use a scheduler for it and specify when the indexer should be run. For example, you can define that the indexer will be run every hour.

How can I support autocomplete and autosuggest in my Search Service?

You need to specify the suggesters property in the index definition. This field requires three pieces of data:

name - name of your suggester,
sourceFields - it can contain one or more fields that will be used as a data source for the autocomplete or autosuggest options,
searchMode - only one is available now - analyzingInfixMatching. It checks the beginning of a given term.

It is important that only one suggester can be defined per index.

Why should I support synonyms in my Search Service?

It makes your search functionality richer. For example, when user tries to search for USA, it will be great if the retrieved results contains also data for United States, United States of America and even USofA. An index definition contains synonymMaps property and in that place you can specify the synonyms.

What is QnA Maker?

QnA Maker enables you to create conversational app with Question and Answer functionality. The user provides the question (in text or speach) and the QnA Maker responds with the best suited answer. You can import data (that is called knowledge base) from documents (PDFs, DOCXs) and websites (URLs) where FAQ section is available.

What is a multi-turn conversation?

Multi-turn is a follow-up prompt that help to specify what the user wants to achieve. For example, when you visit Adobe page, you can see that the chatbot uses multi-turn to determine whether the user is satisfied with the answer. Vodafone uses it to check if the user is their existing customer or a new client. Scandinavian Airlines provides multi-turn conversation to specify the main topic of the discussion. As you can see, additional follow-up prompts can help to create a satisfying bot conversation.

What it chit-chat functionality of QnA Maker?

When you create your knowledge base, you have an option for adding chit-chat. Chit-chat makes your bot more human-friendly and engaging. 'How are you?', 'What is your name?', 'How old are you?' - these are the examples of chit-chat questions. When you want to add these functionality to your QnA Maker, you have several personalities to choose from:

professional,
friendly,
witty,
caring,
enthusiastic.

What is the difference? For example, when you ask 'When is your birthday?' professional personality will respond 'Age doesn't really apply to me' and friendly with 'I don't really have an age'.

What is active learning for QnA Maker?

As a name suggests, you can enable QnA Maker to learn based on user inputs. Thanks to it, you can add new questions (that are suggested by the QnA Maker) to your knowledge base. You have to review and accept or reject QnA Maker suggestions in the portal - there is no other way of managing suggestions.

How can I build my bot?

You have three main options:

Bot Framework SDK that supports C#, JS, Python and Java,
BF (Bot Framework) Command Line Interface,
Bot Framework Composer - it is an IDE for developing bots.

How can I debug my bot using Bot Framework SDK?

There is Bot Framework Emulator that provide you with the functionality of testing and debugging bots. It is a desktop application for Windows, OS X and Linux.

What are Adaptive Cards?

Adaptive Cards can enrich communication by using text, graphics, and buttons to your bot conversation. You can create Adaptive Cards in the Designer (https://adaptivecards.io/designer/) or by Bot Framework SDK.

What is a skill?

In Bot Framework a skill is a bot that performs tasks for another bot. Thanks to it, you can extend your existing bot by consuming another skill (bot). It is good to know that a main skill consumer that interact with the user is called a root bot.

Which Cognitive Services can I integrate into my bot?

It is common to integrate QnA Maker service, LUIS service, and Speech service into the bot.

I created modern flashcard system with spaced repetition - WordTester

Kamil Bugno — Thu, 06 May 2021 15:31:07 +0000

There are several tools for learning foreign words using flashcards and spaced repetition, but I found that most of them don't include the functionality of learning in context. As a result, I remember a lot of foreign words but I have difficulty to use them. One day, I decided to create a system that can resolve this issue - WordTester.

Why?

The main goal was to create an application that requires to specify not only translated word but also a definition and example of the use of the given word. Thanks to it, I believe that the quality of learning and memorization will be increased. Also, I wanted to implement modern flashcards - not flashcards that only have two sides (original word and translated word). WordTester provides flashcards with 11 sides!

How?

I decided that it would be beneficial for me to learn new technology, that is why I chose Blazor for frontend (it turned out to be really great). Backend is implemented in .NET 5.

Some screens

Useful links:
Website
Repository

I hope that thanks to WordTester process of learning a foreign language will be more comfortable and easier for you. Let me know what do you think about my first side project!

Edit: I received feedback from you that the UI is not very good, so a new version has been deployed:

How to protect Azure resources from DDoS?

Kamil Bugno — Thu, 21 Jan 2021 09:28:36 +0000

You can also read this post on my blog: blog.kamilbugno.com

It will not come as a surprise - every resource has its limits. Servers, virtual machines, networks, etc. are not designed in a way that supports unlimited concurrent users. Let’s imagine that someone really wants to make a given website unavailable. How can they do this? Attackers can use that weakness and send a lot of requests to a given website. At some point, the service cannot handle such traffic and become unavailable - it is called Denial-of-service attack.

What is the difference between DoS and DDoS?

When attackers send requests from one source it is DoS (Denial-of-service attack):

Sending traffic from a lot of various sources to make some website unavailable is called DDoS (Distributed denial-of-service):

What does the expression 'many requests' really mean? It turned out that in 2012 the DDoS attack that contained 60 Gbps traffic was enough to make several US banking systems unavailable¹. In 2016 OVH reported attack that reached 1.1 Tbps² and two years later GitHub was attacked by 1.3 Tbps³. If it is hard for you to imagine that huge amount of data, this level of traffic will be enough to transfer ~80 hours of HD video in one second! To make matters worse Cisco indicates that the frequency of DDoS attacks will increase - from 7.9 million per year in 2018 to 15.4 million in 2023⁴. As you can see, the DDoS attack is a real threat so protecting the resources from such kind of attack is indispensable if we want to reduce the possibility that our system will be unavailable for customers.

How can I protect Azure resources from DDoS?

You have two options: you can do nothing, or you can enable the DDoS Protection Standard.

Do nothing

Why can you do nothing and still have your resources protected in Azure? The answer is simple: all Azure resources have enabled Azure DDoS Protection Basic. The main goal of this tier is to protect Azure’s infrastructure. It provides the ability to monitor the traffic and automatically mitigates the attack when it occurs. However, if you want more advanced functionality, this solution may not meet your requirements. It has also one important limitation: Azure can perceive some traffic as safe and inoffensive, but it can be too heavy for your application to be able to handle it.

Use DDoS Protection Standard

Alerts, mitigation reports, DDoS Rapid Response (DRR) team that can help you during the attack and cost guarantee are included only in Standard option. You will be charged about $3,500/month for protecting up to one hundred resources⁵. It is the best option if you want to preserve your application from DDoS since it "will be protected with a profile that is tuned to its expected traffic volume, providing a much tighter defense against DDoS attacks"⁶.

How does Azure DDoS Protection work?

It analyses the traffic using machine learning solutions and if some requests seem to be suspicious, they will be dropped. Traffic that is originated by real users will be forwarded to the given website. Thanks to it during the attack the website is still available for customers and at the same time the attackers are blocked to reach the final service.

How can I enable Azure DDoS Protection Standard?

To have resources that are protected by Azure DDoS service in Standard plan you must take several steps. This part of the article guides you with all the necessary actions. The goal is to enable Azure DDoS Protection Standard for one resource and configure sending email alert when the attack occurs.

1. Create a resource to protect

Let's assume that we would like to protect a virtual machine. Go to the top bar and search for a virtual machine. You can choose any name, region, image, etc. - it doesn't have an influence on later steps. Creating a virtual machine can automatically generate the virtual network that we will use in the next step. When it is done copy the public IP address of the virtual machine for future purposes.

2. Create DDoS Protection plan and assign it to your resource

Go to DDoS protection plans -> click New and fill the required fields. When it is created go to Protected resources section for your plan and add a new resource by choosing your virtual network. As you can see in this case, DDoS Protection plan is assigned to the virtual network, but you can also assign DDoS Protection plan to Application Gateway, Load Balancer or Virtual Machine Scale Set. It is good to know that DDoS plan can be even used across multiple subscriptions.

3. Register resource provider

We would like to use Azure Monitor to collect data and use them to sent alerts. To be able to do this we need to add microsoft.insights resource provider to our subscription. Go to Subscription -> Resource Providers and make sure that microsoft.insights is registered.

4. Create an alert rule

Go to Azure Monitor -> Alerts -> New alert rule -> Select resource and choose your virtual machine public IP address.

In condition section choose as a signal name 'Under DDoS attack or not'. In Alert logic set threshold value as 0. Thanks to it the alert will be activated when the maximum 'under ddos attack or not' value is greater or equal to one.

In actions section create new action groups. For notification select 'Email/SMS message/Push/Voice' and write your email address.

5. Simulate attack on your resources.

There is only one official tool that can be used to simulate DDoS attack on your Azure resources⁷. It is called BreakingPoint Cloud⁸ and it offers a trial subscription that contains 5GB of free outbound traffic. After creating your free account, you need to authorize using your Azure subscription - they would like to be sure that you attack only resources that are created by you. Later, you can choose the details of the attack. At this point, the public IP address of your virtual machine will be useful. During configuration of the attack please pay attention to estimated outbound data - for a free trial you have only 5 GB to use.

6. See the results

After the simulation of the DDoS attack, you can see that DDoS Protection detected suspicious packets.

When you check your inbox, you should see an email about the DDoS attack:

7. Clean your resources

Don't forget to remove unused resources. To delete the DDoS Protection Standard plan, you should go the virtual network -> DDoS Protection and disable it.

After that, you can simply delete your plan and other resources.

During attack simulation, we used the app that needs some permissions in our account. To cancel those permissions, go to MyApplications⁹ and click 'revoke permissions'.

Summary

This near-real live scenario can be used to protect your cloud resources from DDoS attack. Thanks to Standard plan you can be alerted when the attack occurs and have access to metrics collected by Azure Monitor. Also, you can contact DDoS Rapid Response (DRR) team to get some help and you can be sure that you don't be charged for scaling of your services as a result of DDoS attack. As you can see, Azure offers an interesting solution to make your cloud resources safer.

In this article, you can get to know the basics of DDoS attack and understand why it is a genuine issue. I showed you how to configure Azure DDoS Protection for your resource and how to simulate DDoS attack to your virtual machine. I hope that you enjoyed this post!

References:

[1] https://www.cio.com/article/2389721/ddos-attacks-against-us-banks-peaked-at-60-gbps.html
[2] https://arstechnica.com/information-technology/2016/09/botnet-of-145k-cameras-reportedly-deliver-internets-biggest-ddos-ever/
[3] https://www.wired.com/story/github-ddos-memcached/
[4] https://www.cisco.com/c/en/us/solutions/collateral/executive-perspectives/annual-internet-report/white-paper-c11-741490.html
[5] https://azure.microsoft.com/en-ca/pricing/details/ddos-protection/
[6] https://docs.microsoft.com/en-us/azure/ddos-protection/ddos-faq#are-services-unsafe-in-azure-without-the-service
[7] https://github.com/MicrosoftDocs/azure-docs/issues/59335
[8] https://www.keysight.com/zz/en/products/network-security/breakingpoint-cloud.html
[9] https://myapplications.microsoft.com

104 revision questions for AZ-104

Kamil Bugno — Sat, 21 Nov 2020 16:57:45 +0000

You can also read this post on my blog: blog.kamilbugno.com

If you are preparing for AZ-104 exam, you are likely to find this article highly valuable. Together, we will go over the topics that will help you in preparation to become Microsoft Azure Administrator. When I was learning for the exam, I decided to note the most vital facts about Azure. This post doesn't cover all topics required to AZ-104, but I hope that this list can help you to revise your knowledge before the exam. Let's start!

1. What is Azure AD?

Azure Active Directory (AD) is known to be a platform to handle identities. It offers single sign-on (SSO), multi-factor authentication, conditional access policies, etc.

2. What are dynamic membership rules?

You can define membership rules for users. If a given user meets the condition, they are added to a group. Thanks to it you can e.g. create groups for users who are from London and are developers. You don't have to add these users manually.

3. What is user risk policy?

Azure AD Identity Protection offers functionality to detect which users' behaviours are unusual and suspect. You can define the risk level that you accept and determine what should happen when the expected risk is higher than you agreed. For example, you can specify that if the risk of compromising a user account is medium or high then the user is blocked.

4. What is sign-in risk policy?

It is similar to the user risk policy. You can define what should happen when the specified risk that the sign-in is coming from someone else than the user is reached.

5. What is conditional access?

As a name suggest, you can specify what should happen for given users when they try to log in. You can, for example, specify that all guests and external users who use Android devices should use multi-factor authentication:

It is important that you use conditional access only when you disable security defaults. Security defaults are default rules managed by Microsoft that help to protect from well-known identity-related attacks.

6. What are management groups?

You can group multiple subscriptions together by using management groups. It is important that as opposed to resource groups, management groups can be nested, so you can create a logical hierarchy of your subscriptions. For example, the management group "C" contains the subscription "3" and another management group - "D" that holds subscription "4":

7. Why should I use management groups?

Management groups simplify the administration of your subscriptions. They are usually used together with RBAC or Azure Policies.

8. What is RBAC?

RBAC stands for role-based access control. Let's imagine that there are several departments related to your current project: developers, database admins, financial analysts and so on. It will be a good idea to specify which user has what kind of permission. We would like to prevent the situation when financial analysts delete the database or when database admins swap the application's deployment. RBAC offers you an opportunity to define the rules for users who use your Azure subscription. So, you can add necessary rights to developers, other set of permissions to database admins and different privileges to financial analysts.

9. What are the scopes for RBAC?

RBAC can be applied to these levels: management group, subscription, resource group, and a given resource.

10. What are Azure policies?

Azure policies are used to enforce specified rules and effects for your resources. Let's assume that you want to be sure that all the resources have a tag. Or you want to guarantee that your virtual machines are deployed only in a given region. You can create Azure policies and determine what requirements should be met and what will happen when these conditions are or are not fulfilled.

11. What are the scopes for Azure policies?

You can assign a policy to a management group, a subscription, and a resource group. It is good to know that there is also an exclusion option. You can e.g., select that the policy is defined for all resources in your subscription except the resources from a given resource group:

12. What are resource locks?

Let's imagine that you have a lot of virtual machines - for development, testing and production environment. Sometimes you need to delete virtual machines from the development environment only. To be sure, that you don't delete by mistake any virtual machines from testing or production environment, you can use locks. There are two types of locks: delete (it prevents from deleting a resource) and read-only (it prevents from changing the resources):

13. What are the scopes for Azure locks?

You can create a lock for a subscription, resource group, and resource.

14. Why read-only locks can be misleading?

Sometimes it is hard to say what does 'modification' mean for Azure resources. There is a lot of side effects of using this type of lock. For example:

A read-only lock for a virtual machine prevents the users from starting or restarting the virtual machine.
A read-only lock on a storage account prevents the users from listing the keys.

More examples you can find in the official documentation.

15. What will happen when I try to delete a resource with a delete lock?

You will see the information that this operation cannot be completed:

16. What is a tag?

A tag is a name and value pair that can be added to resources in Azure. Thanks to tags you can organize your resources. They are commonly used for cost management, resource management, and automation. Let's assume that you work in a company that maintains two applications: Chat Application and Gallery Application. Each app is hosted in a virtual machine. There are two environments: test and prod. When we add tags to these virtual machines, we will know which virtual machine represents what application and environment:

17. Can a tag be inherited?

No. For example, when you add a tag to a resource group, the resources within this group won't inherit this tag.

18. What is Azure Budget?

You can create a budget limit for your subscription. Thanks to it, you are able to prevent from spending too much money on Azure. It is important that when you run out of budget, your resources are not stopped. The main goal of Azure Budget is to notify you when the specified limit is achieved.

19. What are Azure Action Groups?

During the creation of the budget, you can specify Action Groups. They are a set of effects that should take place when the defined budget limit is met. For example, you can receive an email, phone call or push notification:

There is also an option to run Azure Function, Logic App or Webhook as an effect of the limit hit.

20. When can I use Azure Action Groups?

It is good to know that Action Groups are not designed only to protect your budget, you can use them in other situations. For example, if your average virtual machine CPU is greater than 70%, then you can notify people in your team about this. That condition can be created by using Alerts in Azure Monitor.

21. What is Azure Monitor?

It is a service that provides you with the rich ability to collect and analyze the telemetry of your resources. Azure Monitor contains several subservices and the most important are Application Insights, Log Analytics and Alerts.

22. What is Azure Application Insights?

If you want to monitor your applications, Azure Application Insights is one of the best choices. You can collect information about request rates, response times, server, and browser exceptions and many more in a human-friendly way:

23. What is Log Analytics?

Azure Log Analytics gives you an opportunity to write queries in Kusto query language to analyze your logs. Here are some examples of queries:

To get all data from 'ExampleTable' table:

ExampleTable

To count the number of rows contained in a table:

ExampleTable | count

To search for word 'error' in any property of the data:

ExampleTable | search "error"

It is good to know that Log Analytics can visualise the results of your query and, for example, you will receive a pie chart that you can pin to your dashboard.

24. What is Alerts?

Alerts in Azure Monitor are commonly used to notify you when a certain condition is met. You can use logs and metrics to check if the notification should take place and, for example, send an email to the administrator when your server returns 500 error code.

25. What is Infrastructure as Code (IaC)?

Instead of using the Azure portal to create your resources manually, you can define them in a text file - Azure Resource Manager create all your resources based on that file. The file that contains definitions of resources is called ARM template.

26. Why should I use ARM template?

ARM template can be stored in a version control system and it is the first advantage of using templates. You can review the modifications and you know who and why have made any change. Additionally, you can save a lot of time, because when you want to deploy the same resources for several environments, you can use one template instead of doing these changes manually. The third reason is about avoiding human errors during the deployments. Since you don't have to make all changes by hand, there is a smaller room for mistakes.

27. What is a shared access signature?

Shared access signature (SAS) is used with a storage account to give access to storage resources. You can specify what actions, services and types are allowed. There is even an option to determine a time slot when the SAS is valid:

28. What is AZCopy?

AZCopy is a tool that provides you with a possibility to copy data to/from your storage account. You can use it on Windows, Linux and macOS.

29. Which data I can copy using AZCopy?

You can copy data to/from Blob and File Storage.

30. How can I authorize my actions in AZCopy?

You can use SAS token to be able to copy the data. For Blob Storage you have also the second way of authorization: the credentials can be provided from Azure AD.

31. How can I use AZCopy from a command line?

AZCopy provides several commands that you can use, but there are two that are the most important: azcopy cp and az login.

To log in via Azure AD you should run this command and provide your account login/password:

azcopy login

To upload a single file to your blob storage using SAS authorization you should run this command:

azcopy cp "/yourPath/yourFile.txt" "https://[your-storage-account].blob.core.windows.net/[container]/[path-to-blob]?[SAS-token]"

To download a file from Azure blob storage, you should change the order of arguments:

azcopy cp "https://[your-storage-account].blob.core.windows.net/[container]/[path-to-blob]?[SAS-token]" "/yourPath/yourFile.txt"

A similar command exists for File Storage. When you want to upload a file, you should use:

azcopy cp "/yourPath/yourFile.txt" "https://[your-storage-account].file.core.windows.net/[file-share-name]/[path-to-file]?[SAS-token]"

Here is a command for downloading a file from File Storage:

azcopy cp "https://[your-storage-account].file.core.windows.net/[file-share-name]/[path-to-file]?[SAS-token]" "/yourPath/yourFile.txt"

32. What is Azure Import/Export job?

If you have a lot of data that need to be transferred to/from Azure, you can find the idea of importing/exporting them by using physical disk very appealing. Instead of using an Internet connection, Azure can ship to you disk drives. After you upload/download the data to/from disk, you simply send the disk back:

33. What are storage types supported for Azure Import/Export job?

For import, you can use both File and Blob storage. For export, only Blob storage is supported.

34. What is WAImportExport tool?

It is used during performing Import/Export job. The tool can help you with preparing the disk drives that are sent for import. You can copy your data to the drive and encrypt the volume using WAImportExport.

35. What is scale sets?

If you want to distribute your application across several virtual machines you should use a scale set. It provides the functionality of scaling the number of virtual machines: you can, for example, define that if the total CPU used by your VMs is greater then 85% for 10 minutes, a new virtual machine will be added to the set:

36. Why should I use scale sets?

Scale sets provide you with great flexibility. You can adjust your environment depending on the needs. When few users use your service running on several virtual machines, you can save money by scaling in - the amount of active VMs is decreased. An analogous situation can be for scaling out - when many users request your service, your environment can automatically adjust to that burden.

37. What is a container?

You can run your application with all its dependencies inside a container. It is commonly used to simplify the process of moving application form one environment to another. Instead of installing all the required software in every environment, you can use a container that has installed everything that is needed for the app.

38. What is the difference between a container and a virtual machine?

You can use any operating system inside your virtual machine - it doesn't matter that the host operating system is the same or different. Containers use the operating system of the host, and as a result, they are usually lighter than a virtual machine.

39. What is Azure Kubernetes Service?

When you use containers to run your application, Kubernetes can help you with managing them. If you have a lot of containers, Kubernetes orchestrate them, so you don't need to worry about scaling, access management or deployment of a new version of your app to every available container.

40. What is Azure Kubernetes node?

A node in Kubernetes is a virtual machine.

41. What are Kubernetes pods?

Pods are known to be the smallest deployable units of computing. It simply means that a pod can contain at least one container.

42. What is Kubernetes kubectl?

Kubectl is a command-line client that provides you with the ability to manage your Kubernetes instance. There are a lot of commands, and here I presented only a small subset of them:
To show all your nodes you can use this command.

kubectl get nodes

A similar command is used to display information about your pods:

kubectl get pods

To create resources defined in the YAML file you should use:

kubectl apply -f ./myFile.yaml

When you want to manually scale the resources to 5 you can do it by this command:

kubectl scale --replicas=5 -f ./myFile.yaml

43. What is App Service?

Using App Service you are able to host your web application. You can easily deploy your app, specify the deployment details (like deployment slots), and set the scaling rules. It supports several runtime environments for apps written in .NET, Java, Python, Ruby, NodeJS, and PHP:

44. What is App Service Plan?

In the App Service Plan, you can specify the virtual machines for your web apps to run. It is important that the App Service Plan can contain several apps - but the operating system and location have to be the same for all your apps.

45. What are Deployment Slots?

Deployment slot is your application with a specified hostname. Since there are several ways of how you can publish a new version of your application, Deployment Slots provide you with flexibility on how your app is deployed.

You can, for example, have two Deployment Slots: first for the production version of your app, second that contains new features. You can specify that 80% of the workload will be sent to the old (production) version and 20% to the new version:
You can also set that new version of the app won't be available to the users before it is verified by a QA team. After the testing, you can swap the versions:

46. What types of scaling are supported by App Service Plan?

You can scale both up/down and out/in.

47. What are the differences between scaling up/down and scaling out/in?

By scaling up you can add more CPU, disk space etc. You scale down when you change the resource type to lower piercing tier:

By scaling out you can add additional instances of the same resource. Scaling in is meant to decrease the number of running instances:

48. What is Azure DNS?

Azure DNS provides you with the ability to host domains. When you open your favourite browser and write for example www.dev.to, the name 'www.dev.to' is translated into an IP address of the server that hosts this website. The main goal of DNS is to convert the domain name to the IP address.

49. What are types of DNS supported in Azure?

You can choose from Public DNS and Private DNS. When you buy a new domain for your app, you can use Public DNS to translate the domain name to the IP address of the web app. Private DNS is used inside your virtual network. For example, you can create database.test and server.test domain names and use it instead of IP addresses. It is important that database.test and server.test are not accessible from the Internet since it was creating using Private DNS.

50. What is a virtual network link?

It is used with Private DNS to connect your domain (like database.test) with a virtual network. Thanks to it, the private domain name will be accessible from the virtual network.

51. What is autoregistration?

When you create a virtual network link, you can enable the autoregistration functionality. When you create a new virtual machine in the virtual network, the DNS record for that VM is automatically created:

52. What is Azure Files?

If you have a collection of files, you can use Azure Files to store them in the cloud - this is the main goal of Azure Files.

53. What protocols Azure Files uses?

Both SMB (Server Message Block) and NFS (Network File System) are supported.

54. How can I use Azure Files?

There are two ways of using Azure Files: you can direct mount of an Azure file share or cache Azure file share with Azure File Sync.

55. How can I create Azure File in my subscription?

Azure Files can be treated as a subservice of Azure Storage Account, so you need to create Azure Storage Account to use Azure Files:

56. What is Azure File Sync?

Azure File Sync as a name suggests it is meant to synchronise files. Let's assume that you store files in on-premises file server, and you would like to have them copied in the cloud - you can be sure that your files are synchronized between on-premises and cloud by using Azure File Sync:

It is important that you should install an Azure File Sync agent on the server.

57. What are the differences between server endpoint and cloud endpoint?

Server endpoint is a path on the Windows Server that is synchronized to an Azure file share. Cloud endpoint is simply your Azure file share.

58. What is Azure Sync Group?

Sync group can be interpreted as a logic container. Every endpoint (server and cloud) that are within this sync group are kept in sync. You should create a sync group to use the power of Azure File Sync.

59. How many server endpoints can I have in one sync group?

You can have several server endpoints.

60. What should I do to use Azure File Sync?

There are several steps that you should follow to use Azure File Sync:

Create Azure Files in your subscription.
Register a server by installing an Azure File Sync agent.
Create a sync group.

61. What is a Virtual Network?

Azure resources can communicate using the virtual network. When we create e.g., a VM, we can choose which virtual network would be in use. Each virtual network has an IP address range like 10.0.0.0/24. It is an IP address range using CIDR notation.

62. What is Network Interface (NIC)?

Thanks to the network interface a virtual machine can have access to the rest of the world. The network interface can have one primary IP address and it is attached directly to a virtual machine.

63. Can I have several subnets in a virtual network?

Yes, but important fact is that each of the subnets has to be allocated inside the IP address range. Otherwise, the creation of subnet fails:

64. Can I have no subnet in a virtual network?

No, you have to have at least one subnet in your virtual network. Otherwise, you will not be able to create a virtual network:

65. How many IP addresses are reserved by Azure in my subnets?

Azure reserves 5 IP addresses in each subnet:

66. What is the Network Security Group (NSG)?

The main goal of the network security group is to filter the traffic. You can create several roles and specify which traffic is allowed or denied:

67. To which Azure resources can I assign NSG?

You can assign NSG to a virtual machine (by using NIC - Network Interface) or to a subnet.

68. Can I assign NSG to more than one resources?

Yes, you can e.g., assign one NSG to several NIC, but it is important that the location of these resources have to be the same.

69. Can I assign several NSG to a virtual machine?

Yes. You can assign first NSG to NIC and second to subnet. Then the virtual machine that is inside the subnet will have two NSG. You can check it in Network Watcher -> Effective security rules:

It is important that if one of the NSG denies some traffic then the traffic is not allowed - even when the second NSG permit it.

70. How can I check if NSG blocks the traffic?

You can use Network Watcher to check which rule blocks traffic from your virtual machine to other resources.

71. What will happen when my VM doesn't have any NSG?

If your VM is not associated with any NGS then all traffic is allowed.

72. What is Azure Firewall?

You can create traffic policies using Azure Firewall. If you want to allow or deny some traffic you can do it by defining NAT rules, network rules, and applications rules. It is good to know that you can even enable the functionality of detecting traffic that goes to or from identified malicious domains or IP addresses.

73. What is a route table?

In a route table, you can define how the traffic will be sent by determining a rule:

For example, we defined that all traffic to 10.3.0.0/16 will go through a virtual appliance (10.4.0.0).

74. To which Azure resources can I assign a route table.

You can only assign a route table to a subnet.

75. When is it a good idea to use route tables?

A route table is commonly used when we have an Azure Firewall, and we would like to send all traffic from/to a given subnet through the Firewall. As a virtual appliance, you have to specify the public IP of the Firewall.

76. What is Azure Bastion?

During the creation of a virtual machine, you can choose which port will be opened to connecting to the newly created VM. The disadvantage of this solution is the fact, that having a given port open for all the world is not secure. You can see the following warning about it:

Instead of opening RDP or SSH port of your virtual machine, you can use Azure Bastion to securely connect to the VM. Azure Bastion uses TLS on port 443, so you can connect the VM via web browser:

77. How does Azure Bastion work?

During the creation of Azure Bastion, you have to create a subnet named "AzureBastionSubnet". When you connect to VM by Bastion, the traffic flow is the following:

You connect to Azure Portal (using HTTPS), Azure Portal connects to Bastion (using HTTPS) and Bastion connect to a given virtual machine (using RDP or SSH).

78. What is VNET peering?

When you have two virtual networks, "A" and "B", resources that are inside "A" network cannot communicate to resources from "B" network. The main goal of VNET peering is to enable that communication. To create a peering to a virtual network -> settings -> peerings:

79. Is a virtual network peering transitive?

Let's assume that we have the following situation:

VnetA has a peering connection to VnetB and VnetB has a peering connection to VnetC. Can resources from VnetA communicate to resources in VnetC? No. There is no default transitive peering. If you want to enable that traffic, you should change the settings of these peerings and allow forwarded traffic from VnetB to VnetA and from VnetB to VnetC.

80. Can I create a peering connection to any virtual network I want?

You can create a peering connection between virtual networks in the same region or in different regions, but you cannot connect two virtual networks that have overlapping IP addresses:

81. What is Network Watcher?

Network Watcher helps you to monitor your network. It has several functionalities:

connection troubleshoot - allows you to examine a connection between your VM and another resource. You should use it when you want to diagnose outbound VM communication issues.
connection monitor - thanks to it you can, for example, monitor communication between your VMs.
VPN diagnostics - allows you to diagnose the health of your gateway. If there is a communication issue between your virtual networks, you should use it.
NSG flow log - allows you to log the information about the traffic that goes through your NSG.
IP flow verify - enable you to check if traffic is allowed or denied to/from your virtual machine. We used it to check if NSG blocks the traffic.

82. What are Custom Script Extensions?

Let's imagine that you want to create several virtual machines with SQL Server installed on them. You can connect to every machine and install SQL Server manually, but it can take you a lot of time and is error prone. The main goal of Custom Script Extensions is to take such responsibilities from you. You can define a script that installs SQL Server on your virtual machine and determine that the script is run after the deployment.

83. What is a load balancer?

Load balancer as a name suggests is meant to balancing incoming traffic to resources. Let's assume that we have three virtual machines which serve web application, and we want to distribute the traffic between them. Users can initiate a connection to the load balancer and their flow is sent to one of the VM:

84. What is a health probe?

The load balancer should send traffic only to resources (virtual machines) that are able to receive it. Imagine that one of the virtual machines is unavailable - we don't want to send the user's traffic to it. To prevent such situations the load balancer uses health probes. Every several seconds the load balancer sends TCP/HTTP/HTTPS request to the virtual machines. If a given virtual machine doesn't send any response (for TCP health probes) or returns HTTP response code different than 200 (for HTTP/HTTPS health probes), the probe fails. You can define the number of failed probes when the virtual machine is believed to be unavailable - the load balancer will stop sending user flow to that VM.

85. What are the differences between public and internal load balancers?

A public load balancer is used to balance traffic from the Internet to your VMs. An internal load balancer is used for traffic that is inside your virtual network only.

86. What type of load balancers are available in Azure?

There are two load balancers: Azure Load Balancer and Azure Application Gateway.

87. What is Azure Application Gateway?

Azure Application Gateway is a load balancer, but it uses an application layer of the OSI model. It means that Application Gateway can balance traffic based on attributes of HTTP requests:

88. What is Azure Load Balancer?

Azure Load Balancer uses a transport layer of the OSI model, so it doesn't have access to the HTTP request details.

89. What is a VPN?

VPN stands for a virtual private network. It is used to connect to some resources in a secure way. For example, you can use the VPN to join a virtual network in Azure and thanks to it, you are able to connect to private IPs of your Azure virtual machines. The traffic uses public Internet but is it end-to-end encrypted.

90. What is the difference between Point-to-Site (P2S) and Site-to-Site (S2S) VPN connections?

Point-to-Site (P2S) VPN connection is used when you want to connect your virtual network from a client computer. The computer is treated as 'Point', and your virtual network as a 'Site'.
Site-to-Site (S2S) VPN connection lets you connect Azure virtual network to your on-premises network.

91. What is Virtual Network Gateway?

Virtual Network Gateway is commonly used to create VNet-to-VNet connection. When you want to connect to virtual networks, you can create a virtual network gateway in each of these virtual networks and specify the details of the connection.

It is important that you have to create a subnet named 'GatewaySubnet' that is used by the virtual network gateway.

92. Can I create a VNet-to-Vnet connection to any Azure virtual network I want?

Yes, but the IP address range for these virtual networks should not overlap if you want to connect them.

93. What is VPN Gateway?

It is similar to the virtual network gateway, but it uses encryption before sending the traffic. It is commonly used when you want to connect your on-premises network and Azure virtual network.

94. How many VPN Gateway I can have in one virtual network.

You can have only one VPN gateway, but that gateway can have several connections.

95. What is an active-active connection?

Let's imagine that we want to create S2S VPN connection. We could do it by creating a VPN Gateway in the virtual network and establish one connection. But what will happen when the connection will be broken? You would not be able to send data between your network and on-premises for several seconds. To avoid such situations, we can use active-active connection. It simply means that a VPN gateway has two Gateway IP configurations with two public IP addresses and connects to one or two (dual-redundancy) IP addresses from on-premises:

To use active-active connection you should upgrade your SKU to VpnGw1, VpnGw2 or VpnGw3.

96. What is ExpressRoute?

It is very similar to a VPN, but instead of using the public Internet to send traffic, the connection is established by an Azure connectivity provider.

97. What is WAN?

If you have a highly developed network architecture that contains P2S VPN connections, S2S VPN connections, ExpressRoute and Azure virtual networks and you want to have the ability to connect it all together, you can use WAN:

For example, you can connect from your personal computer using P2S VPN connection to WAN and later to your corporate network by ExpressRoute.

98. What is Azure Backup Service?

As a name suggests, Azure Backup Service is responsible for backing up your data. You can back up several resources in Azure like virtual machine and file share:

99. What is Recovery Services Vault?

Recovery Service Vault is a container for your backups. When you want to create a backup, you should create this vault first.

100. What is the relationship between virtual machines and Recovery Services Vault?

One virtual machine can be backed up by one Backup Service, and the Recovery Services Vault should be in the same region as the virtual machine. One Recovery Services Vault can contain several backups.

101. What is Backup Policy?

In Backup Policy you can define when the backup will be taken and how long it will be available. For example, you can define that the daily backup will be stored for 10 days. Backups that were taken every Sunday will be available for 12 weeks and when the backup was created on the first Sunday of the month, it will be saved for 60 months.

102. What is Update Domain?

Sometimes it is needed to conduct planned maintenance for virtual machines. In that situation, the virtual machine can be restarted and, as a result, it is not available for a short time. To avoid that all your virtual machines are restarted at the same time, you can use Update Domain. All virtual machines in a given Update Domain can be restarted together, but it never happens that several Update Domains are restarted at once.

103. What is Fault Domain?

Fault Domain can be treated as a single hardware rack. If there is a malfunction for the rack, then all allocated resources are not available. To prevent situations when all your resources are unusable because of a hardware failure, you should place them in separate Fault Domains.

104. What is Availability Set?

To ensure high availability of your virtual machines you can use Availability Set. You can define how many Fault Domains and Update Domains it contains:

If you find this blog post helpful for your learning journey in Azure, please write a comment!

Forem: Kamil Bugno

Zero Framework Overhead with Solid.js

Parallel programming in C#

What is parallel programming?

Parallelism vs. asynchronism

Prons and cons of the parallel programming

Parallel programming in C#

Using Parallel.Invoke method

Parallelism with asynchronism

Save values from computations

Exception handling

Synchronization

What is race condition?

Locks

Summary

Demystifying package.json

Dependencies

Versions of dependencies

Installing dependencies

Types of dependencies

Why do we need package-lock.json

Scripts

Summary

Asynchronous programming in C#

Why should we use asynchronous programming?

Desktop app

Web server app

Async and await

1. Method that uses await should be async

2. It is possible to run async operation without await

Consequences

Use Case

3. Async method can return Task, Task<T>, ValueTask<T>, or be void

a) Task vs void

b) Task<T> vs ValueTask<T>

4. Async method can be called in a sync way

Under the hood of asynchronism

How does state machine work?

Thread pool

Summary

Availability in Azure

How much money can the company lose due to the outage?

How to protect our application from downtime?

No protection

Isolated hardware redundancy

Availability zone redundancy

Region redundancy

Availability with scalability

Availability is a huge topic

Driving a robot with a neural network [free meetup online]

RxJS in Angular: from beginner to advanced beginner

Dependency injection in .NET Core

DI and sushi

Why is it not a good idea to prepare sushi without DI?

Sushi with DI is delicious

Advanteges of DI

DI in .NET Core

Summary

Revision questions for AI-102

What are Cognitive Services?

Can I use Cognitive Services as a container?

What are the benefits of having Cognitive Services as a container?

What is Computer Vision API?

What is Form Recognizer?

How can I detect faces on images?

What is Face API?

What is Custom Vision?

How can I use Custom Vision?

What is Video Indexer?

How can I use Video Indexer?

Can I customise Video Indexer?

What is Text Analytics API?

How can I use Text Analytics API?

How many languages are supported for Text Analytics?

What is the Speech service?

Can I customize Speech service?

What is Language Understanding (LUIS)?

How can I use LUIS?

What are utterances?

What is intent?

Using `Parallel.Invoke` method

3. Async method can return `Task`, `Task<T>`, `ValueTask<T>`, or be `void`

a) `Task` vs `void`

b) `Task<T>` vs `ValueTask<T>`