Microsoft Azure: Services Still Down, What’s Going On?

I woke up today to check one of my websites hosted on Microsoft Azure to see a blank page staring at me. I did some preliminary check to make sure I did not break the site over night. Then, I turned to Twitter to see if there’s anything trending about Azure, of course there I found all production services and websites hosted on Azure in the South Central US were down. I tried to access the Azure portal that did not work either, so I could try out anything to remedy the problem.

Below are the updates on the progress for the issue:

Microsoft Azure – Impacted service(s)

Network Infrastructure; Azure Active Directory; SQL Database; Storage; App Service
Impacted region(s)
South Central US; Global
Last update (59 min ago)
CUSTOMER IMPACT: There are currently three identified impact workstreams:

1) Customers with resources in South Central US may experience difficulties connecting to resources hosted in this region. A complete list of impacted services can be found below.
2) Customers using non-regional services, such as Azure Active Directory, may experience intermittent authentication failures in any region.
3) Customers may encounter errors when provisioning new subscriptions.

PRELIMINARY ROOT CAUSE:

1) A severe weather event, including lightning strikes, occurred near one of the South Central US datacenters. This resulted in a power voltage increase that impacted cooling systems. Automated datacenter procedures to ensure data and hardware integrity went into effect and critical hardware entered a structured power down process.
2) As a result, non-regional services, such as Azure Active Directory, encountered an operational threshold for processing requests through the South Central US datacenter. Initial attempts to fail over into other datacenters resulted in temporary traffic congestion for those regions.

ENGINEERING STATUS: Engineers continue to implement the necessary mitigation steps. They have outlined a tentative mitigation workflow:

1) Restore power to the South Central US datacenter (COMPLETED)
2) Recover software load balancers for Azure Storage scale units in South Central US (COMPLETED)
3) Recover impacted Azure Storage scale units in South Central US (In Progress)
4) Recover the remaining Storage-dependent services in South Central US (In Progress)

This mitigation workflow is tentative and subject to change as events develop.

NEXT UPDATE: The next update will be provided by 02:00 UTC 05 Sep 2018 or as events warrant.

Last, I thought I’d share this tweet sent by someone who is also affected by this outage.

How to consume a RESTful API in C#

As a developer you will find yourself in need to consume complex RESTful API as you move forward in your career, so understanding a very basic on might help you get a step ahead. In this short post I will take the opportunity to share how to use the HttpClient class to consume RESTFUL APIs in a C# projects.

What is RESTful API?

Before I proceed into coding, I figured it would be best to describe briefly what exactly is a RESTful API, especially if you just started in web development.
I will try to keep it as simple as possible, so a RESTful API is an application program interface (API) that uses HTTP requests to GET, PUT, POST and DELETE data. For instance, most of the services provided by companies such as Google, Facebook, Twitter have their own API which they expose to other third party companies to get information.

HttpClient Class


HttpClient provides a flexible and extensible API for accessing things exposed through HTTP, which fits perfectly a RESTful API.
Make sure to avoid coding your httpClient call as followed, because you run the risk of having System.Net.Sockets.SocketException due to the connection that is being disposed.


using(var client = new HttpClient())
{
}

Make sure to create a single instance of HttpClient in your program since that will help reduce waste of sockets.

Below is a simple console application I’ve put together to read data out of a RESTFUL API for managing a list of country data, such as capital, language, flag image, and currencies which you can download from github and test it yourself.


using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Web;

namespace ReadCountryData
{
class Program
{
public class Currency
{
public string Code { get; set; }

public string Name { get; set; }

public string Symbol { get; set; }
}

public class Country
{
public List Currencies { get; set; }

public string Name { get; set; }

public string Capital { get; set; }
}

static void Main(string[] args)
{
HttpClient http = new HttpClient();

string baseUrl = "https://restcountries.eu/rest/v2/name/";

string queryFilter = "?fields=name;capital;currencies";

Console.WriteLine("Enter your country name:");

string searchTerm = Console.ReadLine();

string url = baseUrl + searchTerm + queryFilter;

HttpResponseMessage response = http.GetAsync(new Uri(url)).Result;

string responseBody = response.Content.ReadAsStringAsync().Result;

var countries = JsonConvert.DeserializeObject>(responseBody);

PrintCountryInfo(countries);
}

public static void PrintCountryInfo(List countries)
{
int counter = 0;

foreach (var country in countries)
{
counter++;

Console.WriteLine("#" + counter);

Console.WriteLine("Country Name:" + country.Name);

Console.WriteLine("Country Capital:" + country.Capital);

foreach (var currency in country.Currencies)
{
Console.WriteLine("Country Currency:" + currency.Name);

Console.WriteLine("Country Code:" + currency.Code);

Console.WriteLine("Country Symbol:" + currency.Symbol);
}

Console.WriteLine(".......................................................");
}
Console.ReadKey();

}
}
}

So, I hope this post help clear some of doubts you had when it comes to consuming a simple RESTful API in C#.

Testing a resful Web API Using Postman

Recently I have worked on how to create a simple Web API service to manage a list of country capitals. I thought it would be beneficial to some if I put together a quick post to show how to test it using postman.

What is Postman?
Postman is a free API debugging tool which makes working with APIs faster and a bit easier. If you don’t already have it installed, feel free to download it so you can follow along.

How do you get Postman?
Postman is free and you can download it at “https://www.getpostman.com/“. Simple download it and following the instructions for the installation. After successful installation, open it and select HTTP Method and enter the URL of the Web API as shown below.

We’ll test the following commands:

[one_third]

HTTP Verbs

GET

GET

POST

PUT

DELETE

[/one_third]

[one_third]

URL/Endpoints

API/Countries

API/Countries/{id}

API/Countries

API/Countries/{id}

API/Countries/{id}

[/one_third]

[one_third_last]

Description

Get all countries

Get a specific country by ID

Add a new country

Update an existing country

Delete a country

[/one_third_last]


POST API/Countries

Let’s add a few countries to the list.

{
"name": "Afghanistan",
"capital":"Kabul"

}

GET API/Countries

I have submitted 6 countries. Let’s get the list of countries that were submitted using the GET verb in Postman.

GET API/Countries/{id}

To find a specific country I need to fetch it by sending the ID in the URL. See below for more.

PUT API/Countries/{id}

Let say I want to change the first country information because of an typo or maybe I just want to change it to a whole different country.
I need to send a PUT to do so.

Let’s verify to see if the first country in the list has been changed.

DELETE API/Countries/{id}

Now let’s try the delete to see what happens.

After deleting country 1, 2, 3,and 4 we now have 2 countries left.

Build a Web API with ASP.NET Core

Recently I was tasked to put a simple WEB API together to manage a list of country capitals, so I decided to put this post together as a walk-through on how I did it.

What is a Web API?

ASP.Net Web API is a framework used to build HTTP services. By using HTTP this makes it easy to access WEB API across the internet, pretty much any platform or devices can can consumed WEB API with no problem.

In order to facilitate the client communication ASP.NET WEB API provides support for the following HTTP resources, such as GET, PUT, POST, DELETE verbs. In case you would like a more thorough explanation you can follow the tutorial from Microsoft here.

What WEB API I will be building?

This a WEB API will be use to manage country capitals information. It will be able to store, update, find and delete countries.

First create an ASP.NET Core project and name it “Countries”.
Create ASP.NET WEB API project

Once done simply build and run the app (CTRL+F5 to launch the app) and should see the same result page below.

Example: http://localhost:port/api/values

["value1","value2"]

Now that we have the foundation and know it’s working, let’s add the country model to the project.

Add the following Model for country:

namespace Countries.Models
{
public class Country
{
public long Id { get; set; }
public string Name { get; set; }
public string Capital { get; set; }
}
}

Add Database context

The database context is the main class that coordinates Entity Framework functionality for a given data model. This class is created by deriving from the Microsoft.EntityFrameworkCore.DbContext class.


using Microsoft.EntityFrameworkCore;

namespace Countries.Models
{
public class CountryContext:DbContext
{
public CountryContext(DbContextOptions options): base(options)
{
}

public DbSet Countries { get; set; }
}
}

Register Database Context

Next, Register the DbContext via dependency injection (DI) container in order to make it available for use in the controller. ASP.NET core makes it easier since it provides built-in support for dependency injection.
Also, one of the great feature with ASP.NET Core I’ll use here is the “UseInMemoryDatabase” which will create or use a database with the name specified.

Let’s update the startup class with the following snippet.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Countries.Models;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;

namespace Countries
{
public class Startup
{
public Startup(IConfiguration configuration)
{
Configuration = configuration;
}

public IConfiguration Configuration { get; }

// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext(opt => opt.UseInMemoryDatabase("Countries"));
services.AddMvc();
}

// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}

app.UseMvc();
}
}
}

Next, let’s add the controller to put the methods such as the GET, PUT, POST, and DELETE. Let’s use this option to scaffold the different method for the country model.
Adding a controller to the WEB API
Controller creation
As you can see in the controller constructor, it uses dependency injection to inject the DbContext CountryContext into the controller which makes it available to all the methods inside that controller.


using Countries.Models;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace Countries.Controllers
{
[Produces("application/json")]
[Route("api/Countries")]
public class CountriesController : Controller
{
private readonly CountryContext _context;

public CountriesController(CountryContext context)
{
_context = context;
}

// GET: api/Countries
[HttpGet]
public IEnumerable GetCountries()
{
return _context.Countries;
}

// GET: api/Countries/5
[HttpGet("{id}")]
public async Task GetCountry([FromRoute] long id)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}

var country = await _context.Countries.SingleOrDefaultAsync(m => m.Id == id);

if (country == null)
{
return NotFound();
}

return Ok(country);
}

// PUT: api/Countries/5
[HttpPut("{id}")]
public async Task PutCountry([FromRoute] long id, [FromBody] Country country)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}

if (id != country.Id)
{
return BadRequest();
}

_context.Entry(country).State = EntityState.Modified;

try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CountryExists(id))
{
return NotFound();
}
else
{
throw;
}
}

return NoContent();
}

// POST: api/Countries
[HttpPost]
public async Task PostCountry([FromBody] Country country)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}

_context.Countries.Add(country);
await _context.SaveChangesAsync();

return CreatedAtAction("GetCountry", new { id = country.Id }, country);
}

// DELETE: api/Countries/5
[HttpDelete("{id}")]
public async Task DeleteCountry([FromRoute] long id)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}

var country = await _context.Countries.SingleOrDefaultAsync(m => m.Id == id);
if (country == null)
{
return NotFound();
}

_context.Countries.Remove(country);
await _context.SaveChangesAsync();

return Ok(country);
}

private bool CountryExists(long id)
{
return _context.Countries.Any(e => e.Id == id);
}
}
}