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

# Introduction to query parameters?
Query parameters are  optional parameters, which are some key-value pairs that appear after the question mark(`?`) in the URL. 
Note that the question mark sign is used to separate path and query parameters.

In `FastAPI`, other function parameters that are not declared part of the path parameters are automatically interpreted as query parameters. Let us see the code below to understand them.

from fastapi import FastAPI

app = FastAPI()

course_items = [{"course_name": "Python"}, {"course_name": "NodeJS"}, {"course_name": "Machine Learning"}]

@app.get("/courses/")
def read_courses(start: int, end: int):
    return course_items[start : start + end]

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

The *query* is the set of key-value pairs that go after the `?` in a URL, separated by the `&` character.

**Explanation**
* For example, when you visit the URL:
   ```
   http://localhost:8000/courses/?start=0&end=10 
   ```
   The query parameters are:

   * `start`: with a value of `0`
   * `end`: with a value of `10`

   As they are part of the `URL`, they are naturally strings. As with path parameters, when we declare the query parameters with `Python` types (in the example above, as `int`), they are converted to that type and validated against it.
* On **line 1**, we import the `FastAPI` class.

* On **line 3**, we create an instance of `FastAPI` and assign it to the `app` variable.
* On **line 5**, we create sample data that consists of dictionary values containing the course names.
* On **line 7**, we create our route.
* On **line 8**, we define the function that will be called for the above route. Here, we pass the two query parameters that our `API` would expect. Note that we declare the type as `int`, and so, automatic parsing will occur.
* On **line 9**, we return the response.

Let us suppose that you visit the following `URL` without passing the query parameters. 
```a
http://127.0.0.1:8000/courses/ 
```
What do you expect will happen? You will get an error shown in the snapshot below because there are two query parameters required by that function.


Understand and implement the query parameters in 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

Query Parameters in FastAPI

Introduction to query parameters?