Object Storage API

This is a Python microservice created using FastAPI that provides a REST API to upload and download attachments and images to and from an S3 object store.

How to Run

This microservice requires a MongoDB and S3 object storage instance to run against.

Prerequisites

• Docker and Docker Compose installed (if you want to run the microservice inside Docker)
• Python 3.12, MongoDB 7.0 and MinIO installed on your machine (if you are not using Docker)
• Public key (must be OpenSSH encoded) to decode JWT access tokens (if JWT authentication/authorization is enabled)
• MongoDB Compass installed (if you want to interact with the database using a GUI)
• This repository cloned

Docker Setup

Ensure that Docker is installed and running on your machine before proceeding.

1. Create a .env file alongside the .env.example file. Use the example file as a reference and modify the values accordingly.

   cp object_storage_api/.env.example object_storage_api/.env

2. Create a logging.ini file alongside the logging.example.ini file. Use the example file as a reference and modify it accordingly:

   cp object_storage_api/logging.example.ini object_storage_api/logging.ini

Using docker-compose.yml

The easiest way to run the application with Docker for local development is using the docker-compose.yml file. It is configured to start

• A MongoDB instance that can be accessed at localhost:27018 using root as the username and example as the password
• A MinIO instance at localhost:9000 with a console that can be accessed at localhost:9001 using root as the username and example_password as the password
• The application in a reload mode using the Dockerfile.

1. Build and start the Docker containers:

   docker-compose up

   The microservice should now be running inside Docker at http://localhost:8002 and its Swagger UI could be accessed at http://localhost:8002/docs. A MongoDB instance should also be running at http://localhost:27018.

Using Dockerfile

Use the Dockerfile to run just the application itself in a container. Use this only for local development (not production)!

1. Build an image using the Dockerfile from the root of the project directory:

   docker build -f Dockerfile -t object_storage_api_image .

2. Start the container using the image built and map it to port 8002 locally):

   docker run -p 8002:8000 --name object_storage_api_container object_storage_api_image

   or with values for the environment variables:

   docker run -p 8002:8000 --name object_storage_api_container --env DATABASE__NAME=ims object-storage_api_image

   The microservice should now be running inside Docker at http://localhost:8002 and its Swagger UI could be accessed at http://localhost:8002/docs.

Local Setup

Ensure that Python is installed on your machine before proceeding.

1. Create a Python virtual environment and activate it in the root of the project directory:

   python -m venv venv
   source venv/bin/activate

2. Install the required dependencies using pip:

   pip install .[dev]
   pip install -r requirements.txt

3. Create a .env file alongside the .env.example file. Use the example file as a reference and modify the values accordingly. You may need to update the port in DATABASE__HOST_AND_OPTIONS if running the database outside of docker.

   cp object_storage_api/.env.example object_storage_api/.env

4. Create a logging.ini file alongside the logging.example.ini file. Use the example file as a reference and modify it accordingly:

   cp object_storage_api/logging.example.ini object_storage_api/logging.ini

5. Start the microservice using FastAPI's CLI:

   fastapi dev object_storage_api/main.py

   The microservice should now be running locally at http://localhost:8002. The Swagger UI can be accessed at http://localhost:8002/docs.

Using mock data for testing [Optional]

Generating mock data

To populate the database and object storage with mock data for testing IMS first ensure both inventory-management-api and object-storage-api are running in docker and then run.

python ./scripts/dev_cli.py generate -c

This will clear the database and MinIO storage, fetch existing entities from the inventory-management-system-api and generate and add mock data for them.

You can also generate mock attachments just for specific entities by repeatedly using -e ENTITY_ID. This will ensure the entity has at least one attachment and image.

Notes

Application Configuration

The configuration for the application is handled using Pydantic Settings. It allows for loading config values from environment variables or the .env file. Please note that even when using the .env file, Pydantic will still read environment variables as well as the .env file, environment variables will always take priority over values loaded from the .env file.

Listed below are the environment variables supported by the application.