myapp/
│
├── requirements.txt
├── Dockerfile
├── myapp/__init__.py
└── myapp/app.py

requirements.txt
------
numpy
scikit-learn
flask

myapp/__init__.py
------
__author__ = "<someone>"

Dockerfile
------
FROM python:3.8.6-slim

WORKDIR /app

COPY requirements.txt .

RUN pip install -r requirements.txt

COPY myapp myapp

CMD ["python", "-u", "/app/myapp/app.py"]

myapp/app.py
------
from flask import Flask, request, jsonify

import numpy as np
import sklearn
import flask

app = Flask(__name__)


@app.route("/", methods=["GET"])
def home():
    return jsonify(
        {
            "status": "Running RESTful Machine Learning",
            "versions": {
                "numpy": np.__version__,
                "scikit-learn": sklearn.__version__,
                "flask": flask.__version__,
            },
        }
    )


@app.route("/do", methods=["POST"])
def do():
    content = request.json
    text = content.get("text", "")

    # put your machine learning code here

    return (
        jsonify(
            {
                "text": text,
                # put machine learning result here
            }
        ),
        201,
    )


if __name__ == "__main__":
    app.run(debug=True, host="0.0.0.0")

docker build  -t iara-ml:0.0.1 .


docker run  -p 5000:5000 iara-ml:0.0.1

curl -i -X GET \
 'http://0.0.0.0:5000/'

curl -i -X POST \
   -H "Content-Type:application/json" \
   -d \
'{
  "text": "Turn off and try again later"
}' \
 'http://0.0.0.0:5000/do'

weight = data["weight"]
height = data["height"]

with open("/app/myapp/model.bin", 'rb') as f:
      model = pickle.load(f)

predicts = np.array(model.predict_proba([[weight, height]])).flatten()

targets = [
    ({str(target): round(prob, 3)}) for target, prob in zip(model.classes_, predicts)
]

{
    "weight": weight,
    "height": height,
    "targets": targets,
    "datetime": str(datetime.datetime.now())
}

docker run --rm -p 5672:5672 -p 8080:15672 rabbitmq:3-management

myapp/app.py
-----
import pika
import json
import datetime


QUEUE = "iara.do"
QUEUE_REPONSE = "iara.do.response"

connection = pika.BlockingConnection(
    pika.ConnectionParameters(host='192.168.15.112'))

channel = connection.channel()

channel.queue_declare(queue=QUEUE)
channel.queue_declare(queue=QUEUE_REPONSE)


def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)

    data = json.loads(body.decode())

    data["datetime"] = str(datetime.datetime.now())

    channel.basic_publish(
        exchange='', routing_key=QUEUE_REPONSE, body=json.dumps(data))


channel.basic_consume(
    queue=QUEUE, on_message_callback=callback, auto_ack=True)

print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()