Building a Simple Airline Service using Azure Functions in C# and Creating a Client Application

Introduction

In today’s fast-paced world, building and deploying microservices is a common practice for organizations. Azure Functions, a serverless compute service offered by Microsoft Azure, makes it easy to create and deploy small, event-driven, and scalable applications. In this blog post, we’ll walk you through the process of building a simple airline service using Azure Functions in C# and creating a client application to call this service.

Prerequisites

Before we dive into the development process, make sure you have the following prerequisites:

1. An Azure account (sign up for a free account if you don’t have one).
2. Visual Studio or Visual Studio Code (optional but recommended).
3. .NET Core SDK installed (for Azure Functions development).

Part 1: Building the Airline Service with Azure Functions

1. Create an Azure Functions Project: Open Visual Studio or Visual Studio Code and create a new Azure Functions project. Choose the “HTTP trigger” template to create a simple HTTP API.
2. Define Airline Service Endpoints: In the Functions project, you can define endpoints for your airline service. For example, create functions to book flights, check flight status, and list available flights.
3. Implement Function Logic: Write the logic for each function, handling HTTP requests and returning appropriate responses. Here’s an example of a simple “BookFlight” function:

using System.IO;
   using Microsoft.AspNetCore.Mvc;
   using Microsoft.Azure.WebJobs;
   using Microsoft.Azure.WebJobs.Extensions.Http;
   using Microsoft.AspNetCore.Http;
   using Microsoft.Extensions.Logging;

   public static class AirlineServiceFunctions
   {
       [FunctionName("BookFlight")]
       public static async Task<IActionResult> Run(
           [HttpTrigger(AuthorizationLevel.Function, "post", Route = "book")] HttpRequest req,
           ILogger log)
       {
           // Implement your flight booking logic here.
           // You can process the request data and return an appropriate response.
           return new OkObjectResult("Flight booked successfully.");
       }
   }

4. Testing Your Functions: Debug and test your functions locally using the Azure Functions Core Tools. This allows you to verify that your endpoints work as expected.
5. Deploy Your Functions: Publish your Azure Functions to Azure directly from Visual Studio or Visual Studio Code. This will make your airline service accessible on the web.

Part 2: Creating a Client Application

1. Client Application Setup: Create a client application, which can be a console application or a web application, to call your airline service. You can use .NET, JavaScript, or any other language of your choice.
2. HTTP Requests: Use HttpClient or a similar library to send HTTP requests to the endpoints you defined in your airline service. For example, here’s how you can make a request to book a flight in C#:

using System;
   using System.Net.Http;
   using System.Threading.Tasks;

   class Program
   {
       static async Task Main(string[] args)
       {
           var httpClient = new HttpClient();
           var response = await httpClient.PostAsync("YOUR_AIRLINE_SERVICE_URL/book", null);
           var content = await response.Content.ReadAsStringAsync();

           Console.WriteLine(content);
       }
   }

3. Handle Responses: Process the responses received from your airline service as needed in your client application. You can parse JSON responses and display relevant information to the user.

Conclusion

In this blog post, we’ve demonstrated how to create a simple airline service using Azure Functions in C#. Azure Functions provide a flexible and cost-effective way to build small, scalable microservices that can be easily integrated into client applications. Whether you’re building a travel booking app or any other service, Azure Functions can help you get up and running quickly and efficiently.