Question

You need to deploy a serverless solution that meets the following requirements:

• Execution is triggered through an HTTP request.
• You pay only for the time that your code runs.
• You do not have to manage the application infrastructure.

Which Azure service should you use?

You should use Azure Functions. This is a serverless platform that lets you execute your code when needed and pay for the actual runtime only, without worrying about configuration or management of the underlying physical and application infrastructure. Azure Functions can be triggered by various event types, including HTTP requests.

Question

Your company plans to migrate applications and services to the cloud. You recommend for a hybrid cloud to be deployed. Why would you make this recommendation?

To augment on-premises resources by providing overflow capacity

By implementing a hybrid cloud, your company can augment on-premises resources by providing overflow capacity. A hybrid cloud is the combination of two or more cloud models, such as public and private, and provides benefits from both models. It can give businesses the flexibility to use public cloud resources when they need them, while also keeping sensitive data and applications on-premises in a private cloud. A hybrid cloud can also help organizations manage peaks and valleys in traffic more efficiently. By using a hybrid cloud model, businesses do not have to overprovision computing resources in anticipation of high demand; they can simply bring in extra resources from the public cloud when they need them.

Question

Your company has a new policy to restrict administrative access to resources at the resource group and resource scopes in a detailed, granular way. Access will be granted to various groups and individual users. You need to implement the new policy. What should you use?

Role-based access control (RBAC)

You should use RBAC. RBAC supports various scopes, including management groups, subscriptions, resource groups, and resources. Roles can be assigned to groups, users, other security principals, and managed identifies. RBAC has over 70 built-in roles and supports the creation and assignment of custom roles.

Question

Which Azure solution should you use to build a baseline behavioural profile of organisational entities to identify anomalous activity?

Microsoft Sentinel

Microsoft Sentinel is a security information and event manager (SIEM) platform that can analyze data across the enterprise to identify potential threats, including anomalous activities of users or applications, and help with a faster and smarter response.

Question

What is Azure Virtual Desktop (AVD)?

Azure Virtual Desktop (AVD) supports Remote Desktop clients on MacOS and iOS. Other supported platforms include Windows Desktop, Web, Android, and Microsoft Store Client.

You are not charged for the use of AVD on a monthly basis accordingly by active users. AVD is a service that does not require any additional licenses. You can use it with your existing Microsoft 365 or Windows per-user license. However, you are charged for the virtual machines where AVD runs.

AVD users should exist in the same Windows Server AD that is linked to Azure AD. AVD does not support the use of Microsoft accounts or Azure AD B2B when users are sourced from a separate Azure AD tenant.

Question

Which three authentication types are supported by both SSPR and MFA?

The authentication types supported by both SSPR and MFA are:

• Password
• SMS
• Voice call

Question

What is Azure Dedicated Hosts?

A provided physical server is dedicated to your organization’s workload only. Azure Dedicated Hosts are isolated physical servers where you run your organization’s workload only. They are not shared with any other Azure customers to meet corporate compliance guidelines and standards.

You cannot share provided physical servers across your multiple Azure subscriptions. The underlying physical hosts are single-tenant, so they are dedicated to one Azure subscription only.

You are not charged per number of VMs deployed. Azure Dedicated Hosts are charged per dedicated host, regardless of how many VMs you run on the host.

Question

You need to ensure consistent performance for users who access your application, which runs on customised Linux virtual machines. What should you use to provision virtual machines automatically?

You should use scale sets to provision virtual machines automatically. An Azure virtual machine scale set is a group of identical, autoscaling virtual machines in the Azure cloud. Virtual machine scale sets allow you to easily deploy and manage a large number of virtual machines as a single unit, making them ideal for scalable workloads like web servers, application servers, and batch processing jobs. You can create your own virtual machine scale sets from scratch or use pre-configured ones from the Azure Marketplace.

Question

What is a management group?

Management groups let you organize multiple subscriptions as a single management entity to facilitate easier management. You can create managements groups in a hierarchical structure with the top level of the hierarchy at the tenant level and all of the subscriptions are contained in that tenant. Any conditions applied to a management group apply to all subscriptions contained in that management group object.

Question

Your company wants to ensure that it meets its internal compliance goals and that Azure resources are compliant with company standards. This will include ongoing evaluation for compliance and the identification of non-compliant resources. You need to recommend a solution.

What should you use?

You should use Azure Policy. Azure Policy lets a company enforce rules that apply to resources to help ensure compliance with company standards. Policies can also be used to ensure that resources meet service level agreement (SLA) requirements. Resources are evaluated based on policies and non-compliant resources are identified.

Question

What can Application Security Groups help you do?

ASGs let you organize similar servers so you can easily define and implement security policies based on those groups. ASGs let you apply security to the group as a whole.

The post AZ-900 Exam Practice Questions with Answers appeared first on onthecode.

It is not unusual for organisations to ignore monitoring single page applications. Usually, back-end applications such as APIs are monitored via logs, CPU and memory usage.

When it comes to front-end, there is usually not much in the way of monitoring.

Getting started with Application Insights

First of all, create your free Azure account here.

Head over to the portal to create a new resource. Search for ‘application insights’ and click Create.

It will take some time (usually a few seconds) to create the new Application Insights resource. Then, navigate to the resource and find your Instrumentation Key from the right hand side of the screen.

The instrumentation key uniquely identifies the resource you created on Azure. You can use this key with as many components as you wish, including APIs and front end apps.

Install npm package

Install the official package to your Angular application:

npm install @microsoft/applicationinsights-web@latest

This package includes all everything you need to start monitoring your Angular app.

Configure Application Insights

Initialise application insights in the root module of your app. If you have a core module, initialise it there.

// .. app.module.ts 
 providers: [
    {
      provide: ApplicationInsights,
      useFactory: appInsightsFactory
    }
  ]

export function appInsightsFactory(): ApplicationInsights {
  const config: IConfig & IConfiguration = {
    instrumentationKey: environment.appInsightsKey,
    disableTelemetry: environment.appInsightsKey === "",
    enableCorsCorrelation: true
  };

  // send telemetry immediately for dev environment 
  if (!environment.production) {
    config.maxBatchInterval = 0;
    config.maxBatchSizeInBytes = 0;
    config.loggingLevelConsole = 2; //log internal app insights errors to console
  }

  return new ApplicationInsights({ config: config });
}

Please import classes from @microsoft/applicationinsights-web namespace.

The factory method creates an instance of ApplicationInsights client. In addition, it sets the instrumentation key from Angular environment variables. This instance is a singleton, which helps us avoid duplicate telemetry collection.

Setting enableCorsCorrelation to true adds custom headers to each and every request issued by Angular application. These headers are used on the server to correlate requests end to end. If your server has a CORS configuration, be sure to allow the following headers:

"Access-Control-Allow-Headers", "traceparent, request-id, request-context"

The great thing about App Insights is that all telemetry is buffered and automatically sent to the Azure Portal when the user session ends i.e. browser tab is closed. This is especially useful in production environment as it does not impact user experience.

However, it can be annoying in development as you may need to wait or reload page to see data in the portal. That’s why I configure it above to immediately send telemetry in development environment.

Create a monitoring service

The configured ApplicationInsights instance in our application allows us to log messages, exceptions, track events, collect performance metrics and even custom events.

Creating a wrapper service will allow us to set common properties. For example, cloud role name and user identifier can be set on each telemetry item.

import { Injectable } from "@angular/core";
import { ApplicationInsights, SeverityLevel } from "@microsoft/applicationinsights-web";
import { environment } from "src/environments/environment";

@Injectable({ providedIn: "root" })
export class MonitoringService {
  constructor(private appInsights: ApplicationInsights) {
    this.appInsights.loadAppInsights();

    this.appInsights.setAuthenticatedUserContext("USER_EMAIL");

    this.appInsights.addTelemetryInitializer(envelope => {
      envelope.tags = envelope.tags || [];
      envelope.tags.push({ "ai.cloud.role": "MyApp.Web" });
      envelope.data = {
        environment: environment.id
      };
    });
  }

  logError(error: Error): void {
    this.appInsights.trackException({ exception: error });
  }

  logInfo(message: string): void {
    this.appInsights.trackTrace({ message: message, severityLevel: SeverityLevel.Information });
  }

  logPageView(componentId: string, url: string = window.location.pathname): void {
    this.appInsights.trackPageView({ name: componentId, uri: url });
  }

  logEvent(name: string, properties: any): void {
    properties.url = window.location.pathname;
    this.appInsights.trackEvent({ name, properties: properties });
  }
}

Regardless of the severity level, all data logged with trackTrace will appear in the Traces section of Azure Logs. Each log is classified as trace but has a severity level associated, which you can see in the Azure Portal.

If you wish to only send error logs to Azure, you can add the following to configuration:

loggingLevelTelemetry: SeverityLevel.Error

Monitoring from a component

With our wrapper service in place, let’s start capturing some logs in root component:

export class AppComponent implements OnInit {
  constructor(private monitoringService: MonitoringService) { }

  ngOnInit() {
   this.monitoringService.logInfo('App initialised at ' + new Date().toString());
   this.monitoringService.logError(new Error('My bug-free app throws an error'));
   throw new Error('An unhandled exception never happens, really.');
  }
}

Tracking page views

It may be useful to know which pages are popular amongst users. Assuming your application is using deep links, we can listen to router events and log a page view using the monitoring service.

export class AppComponent implements OnInit {
  title = 'AngularAppInsightsDemo';

  constructor(private monitoringService: MonitoringService,
    private router: Router) { }

  ngOnInit() {
    this.router.events
      .pipe(filter((event): event is ResolveEnd => event instanceof ResolveEnd))
      .subscribe((event) => {
        const activatedComponent = this.getActivatedComponent(event.state.root);
        if (activatedComponent) {
          this.monitoringService.logPageView(activatedComponent.id, event.url);
        }
      });
  }

  private getActivatedComponent(snapshot: ActivatedRouteSnapshot): any {
    if (snapshot.firstChild) {
      return this.getActivatedComponent(snapshot.firstChild);
    }

    return snapshot.component;
  }

It helps to have an identifier on your routed components:

export class MyComponent {
  static id = "my important page";
}

Logging unhandled exceptions

Application Insights will automatically capture unhandled exceptions. However, this does not work for Angular applications because the framework swallows unhandled exceptions.

In order to capture unhandled exceptions, you must implement a global error handler and use trackException method.

Create a new file in your project, call it global-error-handler.ts and paste the following code:

import { ErrorHandler, Injectable, Injector } from '@angular/core';
import { MonitoringService } from './monitoring.service';
@Injectable()
export class GlobalErrorHandler implements ErrorHandler {
    constructor(private injector: Injector) { }
    handleError(error: Error) {
        const monitoringService = this.injector.get(MonitoringService);
        monitoringService.logError(error);
    }
}

The error handler gets the instance of MonitoringService on the fly and logs an error.

In order for this to work properly, we need to provide it in our root module.

  providers: [
    {
      provide: ApplicationInsights,
      useFactory: appInsightsFactory
    },
    {
      provide: ErrorHandler,
      useClass: GlobalErrorHandler
    }
  ]

Tracking users

It is important to associate telemetry items with authenticated users. You can achieve this with setAuthenticatedUserContext method, which accepts a user id.

this.appInsights.setAuthenticatedUserContext(userId);

You would ideally call this function when the user session starts e.g. on successful login.

Just make sure to clear user id when they log out, or whenever the session ends.

this.appInsights.clearAuthenticatedUserContext();

Summary

There you have it! It is very easy to monitor Angular applications with Application Insights. In this post, I explained how you can get started quickly. Ff you have any questions or suggestions, drop a comment below!

View code on GitHub

The post Monitoring Live Angular Apps with Application Insights appeared first on onthecode.

Azure Application Insights is a cloud based application monitoring service from Microsoft. You can monitor your applications in all of your environments with Application Insights, including development and production. Microsoft has been shipping Visual Studio with built-in support for Application Insights in Windows. However, Visual Studio for Mac does not yet have the ability to add Application Insights to projects. In this post, I will show you how to add Application Insights telemetry to a .NET Core API using Visual Studio for Mac.

Steps to setup Azure Application Insights telemetry for .NET Core API in Visual Studio for Mac:

• Create the resource on Azure
• Manually add package reference to the API project
• Configure API project with the Instrumentation Key

Getting started with Application Insights

First of all, create your free Azure account here. 

Head over to the portal to create a new resource. Search for ‘application insights’ and click Create.

It will take some time (usually a few seconds) to create the new Application Insights resource. Then, navigate to the resource and find your Instrumentation Key from the right hand side of the screen.

The instrumentation key uniquely identifies the resource you created on Azure. You can use this key with as many components as you wish, including APIs and front end apps.

Configure project

If your project is open in Visual Studio, close it and open the csproj file in TextEdit or a text editor.

Add the following package reference to an ItemGroup.

<PackageReference Include="Microsoft.ApplicationInsights.AspNetCore" Version="2.2.0"/>

Open the project in Visual Studio for Mac and build. This will install all necessary packages for the project to send telemetry data to Azure.

Next, open the configuration file of your project – usually config.json – and add the Instrumentation Key.

...
    },
    "ApplicationInsights": {
        "InstrumentationKey": "xxxx-yyyy-zzzz"
    }
}

If you happen to have multiple environments like staging, you need to create a separate Application Insights resource for each environment. Then, add the instrumentation key in each corresponding configuration file.

Finally, complete the configuration of Application Insights in ConfigureServices inside of Startup.cs:

services.AddApplicationInsightsTelemetry(Configuration);

Application Insights framework reads the whole configuration and interprets your instrumentation key.

3. Monitor Your Application

That’s it! Let’s see some live telemetry.

Startup the project and make a few calls to the API. Head over to the resource in Azure and you’ll see the results live!

Summary

We have seen how easy it is to setup Azure Application Insights for .NET Core Web APIs.

If you have an Angular app, you can enable end-to-end monitoring read my post on how to monitor Angular using Application Insights.

The post Monitoring Live .NET Core APIs with Application Insights appeared first on onthecode.