DEV Community: Samora Machel

Consuming API Using Flask and Containerization with Docker

Samora Machel — Fri, 01 Oct 2021 22:09:40 +0000

Am sure you've heard about API and wondered what is this everyone is talking about. Say no more, by the end you'll have a high level understanding about APIs and be able to consume the in your back-end application.
Let's get started then!

What is an API ?

The acronym API stands for Application Programming Interface. This allows 2 or more computers or softwares to communicate for data manipulation. It can be used to consume, update or delete data. To find out more about API I recommend using the following link.

Now that we got that out of the way we can go to the real stuff.

Getting Started

We are going to build an anime streaming website with a subscription option.
We are going to consume 2 APIs

Beyonic API

Is used for payments thus we'll be helpful while implementing our subscription section

Ani API

We'll consume this API in order to retrieve the animes to display

In order to follow along. I'd recommend using this repository

SamoraMachel / AnimeTV

This is a flask application used for browsing, searching and watching animes. The application is built on top of AniAPI and Beyonic API

AnimeTV

This is a flask application used for browsing, searching and watching animes. The application is built on top of AniAPI and Beyonic API

Prequisites

In order to setup the website you'll first need to install depedancies and setup the .env file to install all the dependancies. First move into the src folder and execute the command

pip install -r requirements.txt

After a successful installation, create a .env file inside the src folder and add in

BEARER_TOKEN=" <your aniapi token> "

BASE_URL = 'https://api.aniapi.com/v1'

WEBSITE_URL = 'http://localhost:5000/'

To get the aniapi token, You'll have to signup to the AniAPI Website

To run the application run :

python main.py

View on GitHub

Prequisites

First we set up our work area. We are going to use a virtual environment to avoid system and application dependencies collision
We first download the virtualenv library using

pip install virtualenv

we can then instantiate our environment using

python -m virtualenv AnimeTv

we are going to use the following libraries which will aid in the construction of our application and also consumption of our the APIs

Flask
beyonic
requests
python dotenv

this can be installed using

pip install flask beyonic requests python-dotenv

Consuming API

Since our main focus is how to work with API, you can get the project template in the repository above

We are going to use the concept of abstraction. Well divide our application into 4 parts

view - this will be responsible for rendering our templates
utils - this will be responsible for consumption of APIs and then abstracting it into functions
main - this will be responsible running the application
config - this will be responsible for configuration changes on the application

We can then create each file respectively like so:

src\
  view.py
  main.py
  utils.py
  config.py

first we configure our application :

we can then use the configured application instance to instantiate our application in the main.py like so:

Now we create the utility function which will be used to produced data which can be rendered by our views

First we have to create a .env file so that we can place our api token and base url there. Therefore it should look something like this:

In our utils.py we can get the environment variables and use them.

We are going to use the request library to consume the APIs as we pass in the API tokens in the header section. We first create a header dictionary for holding all the metadata for the header

The requests library has various methods but we are majorly going to focus on the get method.
which can be used like so

requests.get(URL, headers=URL_HEADERS)

since at times you might have network problem while fetching data or something might just happen during fetching, if not checked, this might break your code. Therefore it is advisable to always place this request in a try and catch block in order to prevent the code from breaking.
To reduce the number of request constantly made to the server we'll have a global object holding the data fetched.

Our functions thus returns the data fetched

Since the beyonic API have been abstracted by the beyonic library we can then use the classes and functions created.
To create a new payment we use the Payment class and call the method create on it passing in the data captured from the user.

We can also get the currencies and transaction from the library like so:

Since we have abstracted all the functionalities we require we can then get back to our view.py and use the functions.

First we need to display all the animes within the page. We first get all the animes and genres using the functions from the utils package and then pass it to our template like so:

When someone makes a subscription we are required to make a new payment thus the data will be posted to our application and be processed one one of the function in the utils library like so:

once we are done creating our views, we then import then to our main.py otherwise the application will not find routes to go to:

Dockerize our application

we can then dockerize our application using the following docker file :

You can then build and run your application using

docker image build . -t animetv
docker run animetv

Hooray!!! You now know how to consume API

To learn more about docker and flask use the following

Getting Started with Docker & Flask

Samora Machel — Mon, 13 Sep 2021 09:12:44 +0000

Probably your wondering what docker is all about, or your just heard it from you friends. Worry no more cause you've come to the right post.

What is docker ?

Docker is a containerization software used to bundle your project into an executable source component shipping with dependencies and operating system libraries that enable the source code to run.
In simple terms docker is a revolutionary software that enable one to bundle his software and enable the programmer run his program in any other computer without pre-installing necessary libraries every time.

What is Flask ?

Flask is a python framework used for creating web application. Why flask? Flask is know for it fast nature and also it is more flexible when you want no restriction in terms of coding paradigm. Its also easy to learn as compared to Django.

Getting Started

Use the following links to install both docker and flask

Docker
Flask

After successful installation, we are going to create a simple flask project that handles both GET and POST.

Create an empty directory named src
inside this directory is where we are going to place our program.

Create and three files like so

The Dockerfile will be used to hold our docker code.

The requirements.txt will be used to hold the dependencies of our project.

The main.py will be used to hold contents of our program.

Working with Flask

In order to first get started with Flask we first import the class Flask from the module flask

We then create an instance of our app using the Flask class

Using the apps' instance we can then create route ( Endpoints ) for our web application. The app is used as a decorator in this instance where we provide:
the name of the endpoint and the method for the endpoint.
Learn more about decorators

Since this is an introduction course we are going to build a simple hello world application.
For a simple web page to display hello world in the page we can add the following

In case you want your endpoint to be used for more than a GET request we can easily add the methods to the method list like so

To run our application well have to call run on the apps' instance. We can optionally provide arguments like:

debug - Tells the app to run in debug or production mode
host - defines the host of the application
port - defines the port number for the application to run in.

If the arguments are not provided then it will use the default values.

you can then use the following command to run your flask application

python main.py

Containerizing our Application

Now that we have our miniature flask application now we can containerize it using docker.
Moving to our Dockerfile we can first add the following code.

FROM - defined the base image or the operations
COPY - copies files and folders from the source to the destination filesystem path
WORKDIR - sets the working directory of the destination filesystem
RUN - runs the commands on top of the current image
EXPOSE - define the network port for our container to listen to during runtime
CMD - defines the command for executing our

We then have to build our application so that it may setup the environment and also download the necessary file for it to run.

We specify the container name. We have names ours getting-started and also the path of our application.

Since we exposed our application to run on port 5000. We can then run our application like so

our application with the run on port 5000.
Our app will be bundled into a container which you can easily share with your fellow programmers.
Hope this article was insightful and you were able to grasp something about docker and flask. If you need a deep dive into docker or flask you can follow the links to help you.

Good luck with you endeavors.