Gain insights into building REST APIs with FastAPI, explore parallel processing in Python, and discover how to deploy APIs on Microsoft Azure with a CI/CD pipeline using GitHub.

Build a REST API Using Python and Deploy It to Microsoft Azure.png

fastapi-docker.tar.gz

FastAPI-test

Python3

In this course, you will learn how to build a REST API using a lighter web framework for Python, i.e., FastAPI. You will learn the basics of FastAPI and learn how to implement parallel processing in Python APIs.

Finally, you will deploy your API on Microsoft Azure and build a Continuous Integration/Continuous Development (CI/CD) Pipeline using Github.

Build a REST API Using Python and Deploy it to Microsoft Azure

# Implement concurrent processing using `FastAPI`
We will be using all the concepts that we have discussed so far to implement an API that will support the concurrent processing of tasks. Later on, we will use this concept to build our final project.

Let us see the code now.

from fastapi import FastAPI
import time
import asyncio

app = FastAPI()

@app.get("/")
async def home():
    tasks = []
    start = time.time()
    for i in range(2):
        tasks.append(asyncio.create_task(func1()))
        tasks.append(asyncio.create_task(func2()))
    response = await asyncio.gather(*tasks)
    end = time.time()
    return {"response": response, "time_taken": (end - start)}

async def func1():
    await asyncio.sleep(2)
    return "Func1() Completed"

async def func2():
    await asyncio.sleep(1)
    return "Func2() Completed"

import React from 'react';
import { shallow, configure } from 'enzyme';
import Adapter from 'enzyme-adapter-react-16';

configure({ adapter: new Adapter() });

import HelloWorld from './app';

var TestResult = function() {
    this.succeeded = false;
    this.reason = "";
    this.input = "";
    this.expected_output = "";
    this.actual_output = "";
}

export const executeTests = function() {

  var results = [];

  result = new TestResult();
  result.input = 'HelloWorld Component';
  result.expected_output = "span containing text 'Hello World'"

  let wrapper = shallow(<HelloWorld />);

  // Call your Challenge function here.

  let type = wrapper.type();
  let testSuccessful = true;
  let failureReason;

  if (type !== 'span') {
    testSuccessful = false;
    failureReason = "You need to render exactly one span HTML element";
  } else if (wrapper.props().children != "Hello World") {
     testSuccessful = false;
     failureReason = "You have rendered wrong message in your span element";
  }

  result.actual_output = wrapper.html();

  if (testSuccessful) {
    result.succeeded = true;
    result.reason = "Succeeded"
  } else {
    result.succeeded = false;
    result.reason = failureReason;
  }

  results.push(result);

  return results;
}


React

Dart

GoJS React

Typescript React

Vue.js

**Explanation**
* From **lines 1** to **3**, we import the required packages.

* On **line 5**, we create an instance of `FastAPI` class and assign it to `app`.
* On **line 7**, we define a `GET` route.
* On **line 8**, we define the corresponding function to handle the route.
* On **line 9**, we create a list to store all the tasks that we want to run.
* On **line 10**, we store the current time in `start`.
* On **line 11**, we run a loop for two times. We append the `async` tasks in the list that we created in the earlier step.
* On **line 14**, we gather all the tasks and wait for them to be completed. Then we store the result of all the tasks in `response`.
* On **line 15**, we again store the time after executing all the tasks.
* On **line 16**, we finally return the response containing the response by running all the tasks and the time taken to run all the tasks.
* On **line 18**, we define an `async` function.

* On **line 19**, we do an `await`. This means that it is safe to switch to another coroutine in the event loop. 
* On **line 20**, we return a simple string response from this `async` function.
* On **line 22**, we define a similar function except for the sleep time, which is again `1` second. 

# Test the API
We can again visit the UI docs to test our API. When you visit the URL:
```
http://localhost:8000/docs
```
You can see a similar view as shown below:

Learn to implement concurrent processing using FastAPI.

Overview of the Course

Building Blocks of an API in Python

Learn the Basics of FastAPI

Optical Character Recognition API Using Tesseract - Project 1

Cloud and Microsoft Azure Services

Text Analytics API Using Azure Cognitive Services - Project 2

Deploy the REST API on Microsoft Azure

Pop Quiz

Appendix

Implement API With Parallel Processing

Implement concurrent processing using `FastAPI`

Pop Quiz

Implement API With Parallel Processing

Implement concurrent processing using FastAPI

Implement concurrent processing using `FastAPI`