Close Menu
    Technology adminBy 4 Mins Read

    Deploying Machine Learning Models with Docker and Kubernetes

    Machine Learning

    Introduction

    Deploying machine learning models is a crucial step in transforming your machine learning projects into production-ready applications. Docker and Kubernetes provide powerful tools for containerising and orchestrating your ML models, ensuring they are scalable, portable, and easy to manage. This article will walk you through the process of deploying a machine learning model using Docker and Kubernetes. Data Scientist Classes that impart advanced machine learning models will train you extensively on using Docker and Kubernetes for deploying machine learning models.

    Why Use Docker and Kubernetes?

    Here are some key advantages of using Docker and Kubernetes. 

    Docker: Allows you to package your application and its dependencies into a single container that can run on any machine, ensuring consistency across different environments.

    Kubernetes: An orchestration platform for managing containerised applications across a cluster of machines, providing features like automated deployment, scaling, and management.

    Step-by-Step Guide

    Here, we will walk through a step-by-step example of containerising and orchestrating an ML model using Docker and Kubernetes. Most Data Scientist Classes conducting advanced ML courses will provide adequate hands-on training in containerising and orchestrating ML models using Docker and Kubernetes.

    Step 1: Containerising the Machine Learning Model with Docker

    1. Install Docker:

                  Follow the official Docker installation guide for your operating system: Docker Installation.

     

    1. Create a Simple Flask App:

    Assume we have a pre-trained machine learning model saved as model.pkl. We will create a Flask application to serve the model.

    # app.py

    from flask import Flask, request, jsonify

    import pickle

    import numpy as np

    app = Flask(__name__)

    # Load the model

    with open(‘model.pkl’, ‘rb’) as f:

        model = pickle.load(f)

    @app.route(‘/predict’, methods=[‘POST’])

    def predict():

        data = request.json

        features = np.array(data[‘features’])

        prediction = model.predict(features.reshape(1, -1))

        return jsonify({‘prediction’: prediction.tolist()})

    if __name__ == ‘__main__’:

        app.run(host=’0.0.0.0′, port=5000)

    1. Create a Dockerfile:

    dockerfile

    Copy code

    # Use the official Python image from the Docker Hub

    FROM python:3.8-slim

    # Set the working directory

    WORKDIR /app

    # Copy the requirements file and install dependencies

    COPY requirements.txt requirements.txt

    RUN pip install -r requirements.txt

    # Copy the rest of the application code

    COPY . .

    # Expose the port

    EXPOSE 5000

    # Run the application

    CMD [“python”, “app.py”]

    1. Create a requirements.txt file:

    text

    Copy code

    flask

    numpy

    scikit-learn

    1. Build and Run the Docker Container:

    bash

    Copy code

    docker build -t ml-flask-app .

    docker run -p 5000:5000 ml-flask-app

    Your Flask app should now be running inside a Docker container and accessible at http://localhost:5000.

    Step 2: Orchestrating with Kubernetes

    1. Install Kubernetes and kubectl:

            Follow the official Kubernetes installation guide Docker Installation available online.

    1. Create a Kubernetes Deployment:

    yaml

    Copy code

    # deployment.yaml

    apiVersion: apps/v1

    kind: Deployment

    metadata:

      name: ml-model-deployment

    spec:

      replicas: 3

      selector:

        matchLabels:

          app: ml-model

      template:

        metadata:

          labels:

            app: ml-model

        spec:

          containers:

          – name: ml-model-container

            image: ml-flask-app:latest

            ports:

            – containerPort: 5000

    1. Create a Kubernetes Service:

    yaml

    Copy code

    # service.yaml

    apiVersion: v1

    kind: Service

    metadata:

      name: ml-model-service

    spec:

      selector:

        app: ml-model

      ports:

        – protocol: TCP

          port: 80

          targetPort: 5000

      type: LoadBalancer

    1. Deploy to Kubernetes:

    bash

    Copy code

    kubectl apply -f deployment.yaml

    kubectl apply -f service.yaml

    This will create a deployment with three replicas of your Docker container and expose it via a Kubernetes service.

    1. Access the Deployed Model:

            Once deployed, Kubernetes will expose your service. You can find the external IP address using:

    bash

    Copy code

    kubectl get services

           The model should now be accessible at the external IP address provided by the LoadBalancer.

    Conclusion

    By leveraging Docker and Kubernetes, you can ensure your machine learning models are deployed in a consistent, scalable, and manageable manner. Docker enables you to containerise your applications, while Kubernetes allows you to orchestrate these containers across a cluster of machines, providing robust deployment solutions for your ML projects. This setup is essential for moving from prototype to production and ensures that your models are ready to handle real-world workloads. You can enrol for a Data Science Course in Bangalore and such urban learning centres to  acquire skills in Docker and Kubernetes.

     

    For More details visit us:

    Name: ExcelR – Data Science, Generative AI, Artificial Intelligence Course in Bangalore

    Address: Unit No. T-2 4th Floor, Raja Ikon Sy, No.89/1 Munnekolala, Village, Marathahalli – Sarjapur Outer Ring Rd, above Yes Bank, Marathahalli, Bengaluru, Karnataka 560037

    Phone: 087929 28623

    Email: enquiry@excelr.com

    Share.