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

# Create a simple `FastAPI` app
In the previous lesson, we have already set up our environment to run `FastAPI` applications.
 Let’s now look at a  simple `FastAPI` code:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def root():
  return {"message": "Hello World"}

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

To start the server, you need to run the following command:
```
uvicorn main:app --reload
```
Here, `main` refers to the file name and `app` refers to the object of `FastAPI` created inside the `main.py` file. The `--reload` parameter makes the server restart after code changes. It should only be used for development purposes.

If you are working on your local computer, once the server is started, you can visit the URL given below to see the response of the API:
```
http://localhost:8000/
```

**Explanation**
* On **line 1**, we import the `FastAPI`, which is a Python class that provides all the functionality for the API.

* On **line 3**, we create an instance of the class `FastAPI` and name it `app`. This `app` is the same one referred to by `uvicorn` in the above command.
* On **line 5**, we create a `GET` path/route. This is the default route or the route after `/`. For example, in a URL like `https://example.com/items/foo`, the path would be `/items/foo`.
* On **line 6**, we define the function that will be executed whenever someone visits the above mentioned route.
* On **line 7**, we finally return a response to the client whenever this route is accessed.


# Points to remember
* If you create your app like this:
   ```a
   my_awesome_api = FastAPI()
   ```
   And put it in a file `main.py`, then you would call `uvicorn` like this:
   ```a
   uvicorn main:my_awesome_api --reload
   ```
* You can also use the other operations instead of `GET`:
   * `@app.post()` can be used if you want the client application to access the route in a `POST` manner.
   * `@app.put()` can be used if you want the client application to access the route in a `PUT` manner.
   * `@app.delete()` can be used if you want the client application to access the route in a `DELETE` manner.

   > There are four more operation types which could also be used. They are `@app.options()`, `@app.head()`, `@app.patch()`, and `@app.trace()`.


Get started with creating your first app 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

Create First App Using FastAPI

Create a simple `FastAPI` app

Pop Quiz

Create First App Using FastAPI

Create a simple FastAPI app

Create a simple `FastAPI` app