import http.server
import socketserver
import os
from minio import Minio

PORT = 8080

remote_url = os.getenv('REMOTE_URL')
minio_host = os.getenv('MINIO_HOST')
minio_port = os.getenv('MINIO_PORT')
minio_url = f'{minio_host}:{minio_port}'

minio_user = os.getenv('MINIO_USER')
minio_password = os.getenv('MINIO_PASSWORD')

bucket_name = 'uploads'

client = Minio(
    minio_url,
    access_key=minio_user,
    secret_key=minio_password,
    secure=False
)

if not client.bucket_exists(bucket_name):
    client.make_bucket(bucket_name)


class Handler(http.server.SimpleHTTPRequestHandler):
    def do_GET(self):
        if '/presignedUrl' in self.path:
            self.send_response(200, 'OK')
            self.send_header('Content-type', 'text/html')
            self.end_headers()

            filename = self.path.split('=')[1]
            original_minio_str = client.presigned_put_object(bucket_name, filename)
            self.wfile.write(str.encode(original_minio_str))
            return
        elif '/files' in self.path:
            self.send_response(200, 'OK')
            self.send_header('Content-type', 'text/html')
            self.end_headers()

            files = list(client.list_objects(bucket_name, recursive=True))
            files_str = '<br>'.join(
                [f'<p>{file.object_name} &emsp; {client.stat_object(bucket_name, file.object_name).metadata}</p>' for
                 file in files])

            self.wfile.write(str.encode(files_str))

            return
        else:
            with open('index.html', 'r') as web_page_file:
                web_page = web_page_file.read()

            self.send_response(200, 'OK')
            self.send_header('Content-type', 'text/html')
            self.end_headers()

            self.wfile.write(str.encode(web_page))

            return


with socketserver.TCPServer(("", PORT), Handler) as httpd:
    print("serving at port", PORT)
    httpd.serve_forever()

 <input type="file" id="selector" multiple>
<button onclick="upload()">Upload</button>

<div id="status">No uploads</div>

<script type="text/javascript">
  // `upload` iterates through all files selected and invokes a helper function called `retrieveNewURL`.
  function upload() {
        // Get selected files from the input element.
        var files = document.querySelector("#selector").files;
        for (var i = 0; i < files.length; i++) {
            var file = files[i];
            // Retrieve a URL from our server.
            retrieveNewURL(file, (file, url) => {
                // Upload the file to the server.
                uploadFile(file, url);
            });
        }
    }

    // `retrieveNewURL` accepts the name of the current file and invokes the `/presignedUrl` endpoint to
    // generate a pre-signed URL for use in uploading that file: 
    function retrieveNewURL(file, cb) {
        fetch(`/presignedUrl?name=${file.name}`).then((response) => {
            response.text().then((url) => {
                cb(file, url);
            });
        }).catch((e) => {
            console.error(e);
        });
    }

    // ``uploadFile` accepts the current filename and the pre-signed URL. It then uses `Fetch API`
    // to upload this file to S3 at `play.min.io:9000` using the URL:
    function uploadFile(file, url) {
        if (document.querySelector('#status').innerText === 'No uploads') {
            document.querySelector('#status').innerHTML = '';
        }
        fetch(url, {
            method: 'PUT',
            body: file
        }).then(() => {
            // If multiple files are uploaded, append upload status on the next line.
            document.querySelector('#status').innerHTML += `<br>Uploaded ${file.name}.`;
        }).catch((e) => {
            console.error(e);
        });
    }
</script>

FROM python:alpine

RUN pip install minio

WORKDIR /server

COPY server.py index.html ./

ENTRYPOINT ["python", "/server/server.py"]

version: "3.8"

services:
  minio:
    image: minio/minio
    command: server /data/minio
    ports:
      - 9000:9000
    environment:
      - MINIO_ROOT_USER=minioadmin
      - MINIO_ROOT_PASSWORD=minioadmin
    networks:
      - minio-local
  server:
    container_name: server
    ports:
      - 8080:8080
    build: .
    environment:
      - MINIO_HOST=192.168.44.76
      - MINIO_PORT=9000
      - MINIO_USER=minioadmin
      - MINIO_PASSWORD=minioadmin
    networks:
      - minio-local


networks:
  minio-local:
    driver: bridge

 user  nginx;
worker_processes auto;
worker_priority -20;

error_log  /var/log/nginx/error.log;
pid        /var/run/nginx.pid;

events {
    worker_connections  4000;
}

http {
    server {
        listen 80;
        resolver 127.0.0.11 valid=5s ipv6=off;

        # To allow special characters in headers
        ignore_invalid_headers off;
        # Allow any size file to be uploaded.
        # Set to a value such as 1000m; to restrict file size to a specific value
        client_max_body_size 0;
        # To disable buffering
        proxy_buffering off;

        proxy_redirect off;

        set $server http://server:8080;

        location /server {
                rewrite ^/server(.*) /$1 break;
                proxy_pass $server;
        }

        set $minio_port 9000;
        set $minio_host minio;
        set $minio_url http://$minio_host:$minio_port;

        location ~* ^/minio-api {
           proxy_set_header X-Real-IP $remote_addr;
           proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
           proxy_set_header X-Forwarded-Proto $scheme;
           proxy_set_header Host $http_host;

           proxy_connect_timeout 300;
           # Default is HTTP/1, keepalive is only enabled in HTTP/1.1
           proxy_http_version 1.1;
           proxy_set_header Connection "";
           chunked_transfer_encoding off;

           proxy_pass $minio_url;
        }
    }
}