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 logging in our *API*
We have already set up the *Application Insights* resource and installed the required package to connect to the service for logging the data. Now, let's make some changes in the code to do the logging operation. 

We will log three things:
* The text
* The sentiment of the overall text
* The key phrases from the overall text

Let us see the code now.

from fastapi import FastAPI
from pydantic import BaseModel
import logging
from opencensus.ext.azure.log_exporter import AzureLogHandler

import utils

app = FastAPI()

logger = logging.getLogger(__name__)
logger.setLevel(10)
# logger.addHandler(AzureLogHandler(connection_string='InstrumentationKey=<YOUR_KEY>'))

headers = {
    "Ocp-Apim-Subscription-Key": "e16626ed2cfd4d87ae51fffbee899079",
    "Content-Type": "application/json",
    "Accept": "application/json"
}

class Model(BaseModel):
    text_to_analyze: list

@ app.post("/")
def analyze_text(text: Model):
    response = {"sentiment": [], "keyphrases": []}
    no_of_text = len(text.text_to_analyze)
    tasks = []
    for i in range(no_of_text):
        document = {"documents": [
            {"id": i+1, "language": "en", "text": text.text_to_analyze[i]}]}
        sentiment = utils.call_text_analytics_api(
            headers, document, endpoint='sentiment')
        keyphrases = utils.call_text_analytics_api(
            headers, document, endpoint='keyPhrases')

        log_data = {
            "custom_dimensions":
            {
                "text": text.text_to_analyze[i],
                "text_sentiment": sentiment["documents"][0]["sentiment"],
                "text_keyphrases": keyphrases["documents"][0]["keyPhrases"]
            }
        }
        logger.info('Text Processed Succesfully', extra=log_data)

        response["sentiment"].append(sentiment["documents"][0])
        response["keyphrases"].append(keyphrases["documents"][0])
    return response


import requests as req


def call_text_analytics_api(headers, document, endpoint):
    response = req.post("https://text-analytics-using-fastapi.cognitiveservices.azure.com//text/analytics/v3.0/" +
                        endpoint, headers=headers, json=document)
    return response.json()


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**
* Almost all the code is the same except for the logging operation. Let us understand it line by line.

* On **lines 3 and 4**, we imported the required packages for logging and connecting to the *Application Insights* resource. 
* On **line 10**, we get the logger.
* On **line 11**, we set the level of logging to `DEBUG`. It means that any log that is at the `DEBUG` level or above this level will be sent to the *Application Insights* service.
* On **line 12**, we tell the logger to connect to the Azure resource by providing the *Instrumentation Key* that we have seen in the previous lesson. You need to uncomment this line and replace your key with `<YOUR_KEY>`.
* Usually, all the logging data is stored in the `Traces` table in *Application Insights*. There are many pre-built columns like timestamp, browser, etc. that are also logged by default by the service. If you want to add your custom log data (*like we want to store three things*), we need to store them in the `cutsom_dimensions` column. It can contain key-value pairs. So, from **lines 36 to 43**, we create the data in the required format.
   > You can add your own data in the `custom_dimensions` dictionary. Do not change the name `custom_dimensions`, else it will not work.

* Finally, on **line 44**, we log the data. It will be logged in the `Traces` table in the *Application Insights* resource.


Now, run the *API* **3 to 4 times**, so that some data is logged to your service. We will later deploy this change on our GitHub and it will automatically be integrated and deployed to *Azure App Services*.

Learn to perform logging using application insights  and Python.

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 Logging in API Using Application Insights

Implement logging in our API