Dockerizing an API built with python on local machine-CodePudding

I have cloned a repository of an API built with python on my local machine and my goal is to be able to send requests and receive responses locally.

I'm not familiar python but the code is very readable and easy to understand, however the repository contains some dependencies and configuration files to Dockerise (and I'm not familiar with Docker and containers too) .

so what are the steps to follow in order to be able to interact with the API locally?.
Here are some files in the repository for config and requirements :

requirements.txt file :

fastapi==0.70.0
pytest==7.0.1
requests==2.27.1
uvicorn==0.15.0

Dockerfile file :

FROM tiangolo/uvicorn-gunicorn:python3.9
COPY ./requirements.txt /requirements.txt
RUN pip install -r /requirements.txt
COPY ./app /app

i already installed Python3 and docker so what's next ?

CodePudding user response：

Adjust Dockerfile

Assuming all code is in the /app directory you have already copied over all your code and installed all the dependencies required for the application.

But you are missing - at least (see disclaimer) - one essential line in the Dockerfile which is actually the most important line as it is the CMD command to tell Docker which command/ process should be executed when the container starts.

I am not familiar with the particular base image you are using (which is defined using the FROM command) but after googling I found this repo which suggests the following line, which does make a lot of sense to me as it starts a web server:

# open port 80 on the container to make it accesable from the outside
EXPOSE 80
# line as described in repo to start the web server
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "80"]

This should start the web server on port 80 using the application stored in a variable app in your main.py when the container starts.

Build and run container

When you have added that you need to build your image using docker build command.

docker build -t asmoun/my-container .

This builds an container image asmoun/my-container using the Dockerfile in the current directory, hence the .. So make sure you execute that when in the directory with the Dockerfile. This will take some time as the base image has to download and dependencies need to be installed.

You now have an image that you can run using docker run command:

docker run --name my-fastapi-container -d -p 80:80 asmoun/my-container

This will start a container called my-fastapi-container using the image asmoun/my-container in detached mode (-d option that makes sure your TTY is not attached to the container) and define a port mapping, which maps the port 80 on the host to port 80 on the container, which we have previously exposed in the Dockerfile (EXPOSE 80).

You should now see some ID getting printed to your console. This means the container has started. You can check its state using docker ps -a and you should see it marked as running. If it is, you should be able to connect to localhost:80 now. If it is not use docker logs my-fastapi-container to view the logs of the container and you'll hopefully learn more.

Disclaimer

Please be aware that this is only a minimal guide on how you should be able to get a simple FastAPI container up and running, but some parameters could well be different depending on the application (e.g. name of main.py could be server.py or similar stuff) in which case you will need to adjust some of the parameters but the overall process (1. adjust Dockerfile, 2. build container, 3. run container) should work. It's also possible that your application expects some other stuff to be present in the container which would need to be defined in the Dockerfile but neither me, nor you (presumably) know this, as the Dockerfile provided seems to be incomplete. This is just a best effort answer.

I have tried to link all relevant resources and commands so you can have a look at what some of them do and which options/ parameters might be of interest for you.