Nenba Jonathan

Software Developer


« back

Create a simple python web service, dockerize and publish it

Posted on by Jonathan Nenba | Read comments
python api fastapi docker uvicorn

Welcome to this new post where we will create a simple API and create a docker image that we can store in the official Docker registry.

So what is a web service, it’s any application that runs on the internet and allows the processing of data and provides a result, it can be an application that looks for the weather forecast of your city and sends it back to you, or a service that every time you upload images in your online storage space will try to study the data to know you better (this is a bit more complex).

Basically what we are going to implement here is a simple web API that will return some data when some endpoint is called, but before we start what is an API?


Defined as Application Programming Interface, an API is a set of definition and protocol allowing services or products to communicate without the implementation of a whole one.

To follow this post you will need to know the basics of python, flask and also docker. Have python and docker installed on your machine.

In this post we are going to develop a Python API to return a certain amount of information (a users for example) so that other services such as a mobile application for example can consume it.

In order to facilitate the development we will use the FastAPI Framework of python for our development. without delay we will start

the first thing is to go to your favorite workspace for me is the Workspace folder and create a folder for our project

mkdir simple-users-api

in order to separate our environment from the rest of our python programs the first thing to do is to create a virtual environment

python3 -m venv .venv

you will see a .venv file being created. The next step will be to initialize the git repository for our project and to add the .gitignore file (which will allow us to ignore certain files or folders when we share our code with other developers)

git init && touch .gitignore

now we can open our folder with our favorite code editor (VS Code for me) so we’ll create a file called __main.py__ which will contain the code of our little application before that we’ll activate our virtual environment with the command

source .venv/bin/activate

We can then install the different python packages that we will need for our application

pip install fastapi "uvicorn[standard]"

When all the steps are finished with success you can type the command if you want to see the different dependencies of your project and also keep them in a requirements.txt file so that another developer can easily run your project in his local machine and contribute too.

pip freeze > requirements.txt

you will get a file of this kind.


In the following we will write a small program

from typing import Union
from fastapi import FastAPI, HTTPException

app = FastAPI()

class User:
	def __init__(self, id, first_name=None, last_name=None): = id
		self.first_name = first_name
		self.last_name = last_name

users = [
	User('4d398f27-3261-45a2-b014-30c90d6e1d30', 'Alice', 'Life'),
	User('a01f2538-c17c-4401-ba53-5b8da27b928f', 'Bob', 'Prink'),
	User('c26a00fd-d4a1-42a4-ae20-ef6a25326cfd', 'Marley', 'Sant'),

def index():
	return users

def get_unique(user_id: str):
	found_user = None;
	for user in users:
		if == user_id:
			found_user = user
	if found_user:
		return found_user
	raise HTTPException(status_code=404, detail="User not found")

Not too much explanation for our program which exposes two endpoints namely GET /api/users and GET /api/users/{id} which allows respectively to have the list of users and the information of a user with the id.

to launch our program and see the result run this command in your terminal, you will get the server that is launched and your application will be available at the address of your machine

uvicorn main:app --reload
INFO:     Will watch for changes in these directories: ['*****']
INFO:     Uvicorn running on (Press CTRL+C to quit)
INFO:     Started reloader process [80035] using WatchFiles
INFO:     Started server process [80037]
INFO:     Waiting for application startup.
INFO:     Application startup complete.

Our application is finally ready to be consumed by other services (for the moment our browser).

The next step will be to create an image of our application and from this image create as many containers as we want.

Create the Dockerfile at the root of our project

FROM python:3.9


COPY ./requirements.txt /

RUN pip install --no-cache-dir --upgrade -r requirements.txt

COPY . .

CMD ["uvicorn", "main:app", "--host", "", "--port", "8000"]

the Docker file allowing to create our image is ready we can then execute the command and being at the root of our project of course

docker build . -t nejos97/simple-users-api    

nejos97 here represents my docker pseurdo that will allow me to push my images directly into my account.

To create a container with our image that we just built

docker run -p 8000:8000 nejos97/simple-users-api 

By executing this command our application will be created and launched in the container and available in our local machine on the same port 8000 as the container. So our image contains our dimension and is ready to be published in the docker registry.

For the next step, create an account if you haven’t already done so and connect (on Docker Desktop) and then run the following command to push your images on the docker registry

docker image push nejos97/simple-users-api

Through our program I hope that it would have allowed you to know some basics of python web services more precisely the API and also.