Docker का उपयोग करके किसी एप्लिकेशन को कंटेनराइज़ कैसे करें

जैसे-जैसे मशीन लर्निंग एप्लिकेशन जटिल होते जाते हैं, हमारे ML मॉडल्स को डेवलपमेंट से प्रोडक्शन तक ले जाना सिर्फ अच्छा कोड लिखने तक सीमित नहीं रहता। यह सुनिश्चित करना भी जरूरी है कि हमारा एप्लिकेशन अलग-अलग वातावरणों में एक जैसा चले। यहीं कंटेनराइज़ेशन काम आता है। लेकिन कंटेनराइज़ेशन आखिर है क्या, और यह मशीन लर्निंग वर्कफ़्लोज़ के लिए गेम-चेंजर क्यों है?

कंटेनराइज़ेशन एक हल्का, पोर्टेबल तरीका है जिसमें किसी एप्लिकेशन को उसकी सभी डिपेंडेंसीज़, लाइब्रेरीज़ और कॉन्फ़िगरेशन सहित एक यूनिट (कंटेनर) में पैकेज किया जाता है। पारंपरिक वर्चुअल मशीनों (VMs) के विपरीत, कंटेनर्स होस्ट सिस्टम के ऑपरेटिंग सिस्टम को साझा करते हैं, जिससे वे तेज, अधिक कुशल और स्केल करना आसान हो जाते हैं। 

डेटा साइंटिस्ट्स और ML इंजीनियर्स के लिए, इसका मतलब है कि आप अपनी लोकल मशीन पर एक मॉडल बना सकते हैं और उसे कहीं भी—क्लाउड प्लेटफ़ॉर्म, सर्वर, या किसी सहकर्मी के लैपटॉप—पर बिना कम्पैटिबिलिटी समस्याओं की चिंता किए डिप्लॉय कर सकते हैं।

इस ट्यूटोरियल में, हम Docker और Kubernetes का उपयोग करके एक मशीन लर्निंग एप्लिकेशन को कंटेनराइज़ करना देखेंगे। अंत तक, आप जान जाएंगे कि कैसे:

1. अपने ML एप्लिकेशन के लिए Docker कंटेनर बनाएं।
2. Kubernetes का उपयोग करके अपने कंटेनराइज़्ड एप्लिकेशन को डिप्लॉय और मैनेज करें।
3. प्रोडक्शन वातावरण में अपने ML एप्लिकेशन को स्केल और मॉनिटर करें।

यदि आप Docker में नए हैं, तो हमारा गाइड देखें Docker शून्य से कैसे सीखें। आप हमारा यह कोर्स भी कर सकते हैं, Docker और Kubernetes के साथ कंटेनराइज़ेशन और वर्चुअलाइज़ेशन.  

पूर्वापेक्षाएँ

शुरू करने से पहले, आपको Python, मशीन लर्निंग वर्कफ़्लोज़, और कमांड लाइन के साथ काम करने की बुनियादी समझ होनी चाहिए। Docker कॉन्सेप्ट्स (जैसे, इमेजेज़, कंटेनर्स, बेसिक कमांड्स) से परिचित होना बेहतर है, और Kubernetes का बुनियादी ज्ञान वैकल्पिक है, लेकिन डिप्लॉयमेंट और स्केलिंग के लिए सहायक है। 

कंटेनराइज़्ड एप्लिकेशन क्या है?

कंटेनराइज़्ड एप्लिकेशन वह सॉफ़्टवेयर एप्लिकेशन है जिसे उसकी सभी डिपेंडेंसीज़, लाइब्रेरीज़ और कॉन्फ़िगरेशन के साथ एक हल्की यूनिट—कंटेनर—में पैक किया गया हो। मशीन लर्निंग एप्लिकेशनों के लिए, इसका मतलब है कि आपके प्रशिक्षित मॉडल से लेकर वह जिन Python लाइब्रेरीज़ पर निर्भर है, सबकुछ पैक करना, ताकि आपका एप्लिकेशन हर जगह एक जैसा चले।

पारंपरिक एप्लिकेशन बनाम कंटेनराइज़्ड एप्लिकेशन

मशीन लर्निंग एप्लिकेशनों के लिए कंटेनराइज़ेशन क्यों महत्वपूर्ण है

जब आप मशीन लर्निंग एप्लिकेशन विकसित कर रहे होते हैं, तो आपने शायद “मेरी मशीन पर तो चल रहा है” वाली समस्या देखी होगी। हो सकता है आपका मॉडल आपके लैपटॉप पर बिल्कुल सही चले, लेकिन क्लाउड पर डिप्लॉय होने पर फेल हो जाए, या किसी सहकर्मी के पास आपके परिणाम पुन:उत्पादित न हों क्योंकि उनके पास scikit-learn या TensorFlow के अलग वर्ज़न इंस्टॉल हैं। 

कंटेनराइज़ेशन इन समस्याओं को आपके एप्लिकेशन के लिए एक सुसंगत, आइसोलेटेड वातावरण बनाकर हल करता है। यह चीजें कंटेनराइज़्ड एप्लिकेशन को मशीन लर्निंग के लिए बेहतर बनाती हैं:

1. संगति: आपका एप्लिकेशन अलग-अलग वातावरणों—डेवलपमेंट, टेस्टिंग और प्रोडक्शन—में एक जैसा व्यवहार करता है।
2. आइसोलेशन: हर कंटेनर अपने अलग वातावरण में चलता है, जिससे अलग-अलग एप्लिकेशनों या डिपेंडेंसीज़ के बीच कॉन्फ्लिक्ट नहीं होते।
3. पोर्टेबिलिटी: कंटेनर्स किसी भी प्लेटफ़ॉर्म पर चल सकते हैं जो कंटेनराइज़ेशन सपोर्ट करता है—लोकल मशीन, क्लाउड सर्विस, या ऑन-प्रिमाइसेस सर्वर।
4. स्केलेबिलिटी: अधिक रिक्वेस्ट्स हैंडल करनी हैं? कई इंस्टेंस चलाकर कंटेनर्स आपके एप्लिकेशन को क्षैतिज रूप से स्केल करना आसान बनाते हैं।

कंटेनर्स बनाम वर्चुअल मशीनें

हालाँकि कंटेनर्स और वर्चुअल मशीनें (VMs) दोनों एप्लिकेशनों को आइसोलेट करने के लिए उपयोग होती हैं, वे ऑपरेशन और उपयोग के मामलों में काफी अलग हैं। यहाँ प्रमुख अंतर और फायदे दिए गए हैं:

मशीन लर्निंग एप्लिकेशनों के लिए, ये अंतर मायने रखते हैं। जब आपको अपने मॉडल को अधिक प्रीडिक्शंस संभालने के लिए स्केल करना हो, या A/B टेस्टिंग के लिए अपने मॉडल के कई वर्ज़न डिप्लॉय करने हों, तो कंटेनर्स वह फुर्ती और संसाधन दक्षता देते हैं जिसकी आपको जरूरत है।

कंटेनराइज़ेशन और वर्चुअलाइज़ेशन के बारे में अधिक जानने के लिए यह लर्निंग ट्रैक देखें: Docker और Kubernetes के साथ कंटेनराइज़ेशन और वर्चुअलाइज़ेशन.

मशीन लर्निंग एप्लिकेशन को कंटेनराइज़ कैसे करें 

नीचे के सेक्शन्स में, हमने एप्लिकेशन को कंटेनराइज़ करने की चरण-दर-चरण गाइड दी है: 

1. अपना वातावरण सेट करना

मशीन लर्निंग एप्लिकेशन को कंटेनराइज़ करना शुरू करने से पहले, हमें जरूरी टूल्स इंस्टॉल करने और वातावरण तैयार करने की जरूरत है। इस सेक्शन में आप Docker इंस्टॉल करना और कंटेनराइज़ेशन के लिए एक सरल मशीन लर्निंग एप्लिकेशन तैयार करना सीखेंगे।

आवश्यक टूल्स

किसी मशीन लर्निंग एप्लिकेशन को कंटेनराइज़ करने के लिए आपको ये टूल्स चाहिए:

1. Docker: कंटेनर्स को बनाना, शिप करना और चलाना—इसके लिए प्लेटफ़ॉर्म।
2. Kubernetes (वैकल्पिक): बड़े पैमाने पर कंटेनर्स को मैनेज करने के लिए ऑर्केस्ट्रेशन टूल। (इसे हम आगे ट्यूटोरियल में कवर करेंगे।)

आइए Docker इंस्टॉल करने से शुरू करें।

चरण 1: Docker इंस्टॉल करना

Docker Windows, macOS और Linux के लिए उपलब्ध है। नीचे आपके सिस्टम पर Docker इंस्टॉल करने के स्टेप्स दिए गए हैं।

Windows/macOS के लिए:

1. जाएँ Docker वेबसाइट पर।
2. Docker Desktop डाउनलोड और इंस्टॉल करें।
3. इंस्टॉलर द्वारा दिए गए निर्देशों का पालन करें।

Linux (Ubuntu/Debian) के लिए:

अपना टर्मिनल खोलें और Docker इंस्टॉल करने के लिए निम्न कमांड्स चलाएँ:

# Update your package list
sudo apt-get update

# Install required packages to allow apt to use a repository over HTTPS
sudo apt-get install -y apt-transport-https ca-certificates curl software-properties-common

# Add Docker’s official GPG key
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# Add the Docker repository to your system
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Update your package list again
sudo apt-get update

# Install Docker
sudo apt-get install -y docker-ce docker-ce-cli containerd.io

# Verify Docker installation
sudo docker --versionसंचालित द्वारा

यह इंस्टॉलेशन प्रक्रिया आपके सिस्टम में Docker रिपॉज़िटरी जोड़ती है, GPG की के साथ उसकी प्रामाणिकता सत्यापित करती है, और Docker इंजन को इसकी कमांड-लाइन टूल्स सहित इंस्टॉल करती है।

चरण 2: Docker इंस्टॉलेशन सत्यापित करें 

Docker इंस्टॉल होने के बाद, कमांड प्रॉम्प्ट में निम्न कमांड चलाकर जाँचें कि यह सही से काम कर रहा है:

# Check Docker version
docker --version

# Run hello-world container
docker run hello-worldसंचालित द्वारा

यह एक हल्की टेस्ट इमेज पुल करता है और उसे कंटेनर के रूप में चलाता है। यदि सफल रहा, तो आपको एक स्वागत संदेश दिखाई देगा जो पुष्टि करता है कि आपका इंस्टॉलेशन सही ढंग से काम कर रहा है, जैसा कि नीचे दिखाया गया है:

Hello from Docker!संचालित द्वारा

2. अपना मशीन लर्निंग एप्लिकेशन तैयार करना

अब जब Docker इंस्टॉल हो चुका है, तो आइए कंटेनराइज़ेशन के लिए एक सरल मशीन लर्निंग एप्लिकेशन तैयार करें। इस ट्यूटोरियल में, हम एक बेसिक Python स्क्रिप्ट का उपयोग करेंगे जो एक प्री-ट्रेंड मॉडल लोड करता है और Flask API के जरिए प्रीडिक्शंस सर्व करता है।

चरण 1: एक सरल ML एप्लिकेशन बनाएँ

अपने प्रोजेक्ट के लिए एक नया डायरेक्टरी बनाइए और निम्न फ़ाइलें जोड़िए:

1. app.py: Flask API के जरिए प्रीडिक्शंस सर्व करने के लिए Python स्क्रिप्ट।
2. requirements.txt: Python डिपेंडेंसीज़ की सूची।

app.py के लिए कोड यह रहा:

# Import required libraries
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from flask import Flask, request, jsonify
import numpy as np

# Initialize Flask app
app = Flask(__name__)

# Load and prepare the model
iris = load_iris()
X, y = iris.data, iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
model = RandomForestClassifier(random_state=42)
model.fit(X_train, y_train)

@app.route('/predict', methods=['POST'])
def predict():
    # Get features from request
    features = request.json['features']
    
    # Make prediction
    prediction = model.predict([features])
    
    return jsonify({'prediction': int(prediction[0]),
                   'class_name': iris.target_names[prediction[0]]})

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)संचालित द्वारा

यह कोड Iris डेटासेट लोड करता है, एक रैंडम फॉरेस्ट क्लासिफ़ायर ट्रेन करता है, और एक Flask API एंडपॉइंट सेटअप करता है जो फीचर वैल्यू लेता है और प्रीडिक्शंस लौटाता है। हम इसे वेब सर्विस के रूप में बना रहे हैं ताकि यह कंटेनराइज़ेशन के लिए उपयुक्त हो।

चरण 2: बनाएँ requirements.txt

यह requirements.txt फ़ाइल स्क्रिप्ट चलाने के लिए जरूरी Python लाइब्रेरीज़ की सूची देती है। इसे app.py के समान डायरेक्टरी में बनाएँ:

# requirements.txt
scikit-learn==1.3.0
numpy==1.24.3
flask==2.0.1संचालित द्वारा

यह हमारी एप्लिकेशन के लिए जरूरी Python पैकेजों के सटीक वर्ज़न बताता है। फिक्स्ड वर्ज़न रखने से हमारा कंटेनराइज़्ड एप्लिकेशन सुसंगत और पुनरुत्पाद्य रहता है।

अब जबकि हमारा वातावरण सेट है और हमारा ML एप्लिकेशन तैयार है, हम अपना पहला Docker कंटेनर बनाने की ओर बढ़ सकते हैं। अगले सेक्शन में, हम एक Dockerfile लिखेंगे और अपने Flask-आधारित ML एप्लिकेशन के लिए Docker इमेज बनाएँगे।

3. अपना पहला Docker कंटेनर बनाना

अब जब हमारा मशीन लर्निंग एप्लिकेशन तैयार है, अगला कदम इसे Docker का उपयोग करके कंटेनराइज़ करना है। इसमें एक Dockerfile बनाना शामिल है, जो Docker इमेज बनाने के निर्देशों वाली स्क्रिप्ट होती है। इमेज बनने के बाद, हम इसे कंटेनर के रूप में चला सकते हैं।

Dockerfile उदाहरण: Dockerfile लिखना

एक Dockerfile एक टेक्स्ट डॉक्युमेंट है जिसमें इमेज तैयार करने के सभी कमांड होते हैं। हमारे Flask-आधारित ML एप्लिकेशन के लिए इसे ऐसे बनाएं।

1. app.py और requirements.txt वाली उसी डायरेक्टरी में, Dockerfile नाम से एक नई फ़ाइल बनाएँ (कोई फ़ाइल एक्सटेंशन नहीं)।
2. Dockerfile में नीचे दिया कंटेंट जोड़ें:

# Use an official Python runtime as the base image
FROM python:3.9-slim

# Set the working directory in the container
WORKDIR /app

# Copy the requirements file into the container
COPY requirements.txt .

# Install the Python dependencies
RUN pip install --no-cache-dir -r requirements.txt

# Copy the rest of the application code into the container
COPY . .

# Expose port 5000 for the Flask app
EXPOSE 5000

# Define the command to run the Flask app
CMD ["python", "app.py"]संचालित द्वारा

व्याख्या:

• FROM python:3.9-slim: हम आधिकारिक Python 3.9 स्लिम इमेज को बेस इमेज के रूप में इस्तेमाल कर रहे हैं। स्लिम वर्ज़न हल्का है और कंटेनराइज़्ड एप्लिकेशनों के लिए आदर्श है।
• WORKDIR /app: यह कंटेनर के अंदर वर्किंग डायरेक्टरी /app सेट करता है। आगे की सभी कमांड यही से चलेंगी।
• COPY requirements.txt .: आपकी लोकल मशीन से requirements.txt फ़ाइल कंटेनर में कॉपी करता है।
• RUN pip install --no-cache-dir -r requirements.txt: requirements.txt में सूचीबद्ध Python डिपेंडेंसीज़ इंस्टॉल करता है। --no-cache-dir फ्लैग कैश स्टोर न करके इमेज साइज कम करता है।
• COPY . .: आपकी लोकल मशीन की करंट डायरेक्टरी की सभी फ़ाइलें कंटेनर की /app डायरेक्टरी में कॉपी करता है।
• EXPOSE 5000: 5000 पोर्ट एक्सपोज़ करता है, जिस पर हमारा Flask ऐप सुनता है।
• CMD ["python", "app.py"]: कंटेनर स्टार्ट होने पर Flask ऐप चलाने की कमांड निर्धारित करता है।

Docker इमेज बनाना और टेस्ट करना

Dockerfile तैयार होने के साथ, अब हम Docker इमेज बना सकते हैं और उसे कंटेनर के रूप में चला सकते हैं। 

चरण 1: Docker इमेज बनाएं

Docker इमेज बनाने के लिए टर्मिनल में निम्न कमांड चलाएँ:

docker build -t ml-flask-app .संचालित द्वारा

यह कमांड करंट डायरेक्टरी के Dockerfile से Docker इमेज बनाती है। -t ml-flask-app फ़्लैग इमेज को ml-flask-app नाम से टैग करता है, जिससे बाद में रेफ़र करना आसान हो जाता है।

चरण 2: Docker कंटेनर चलाएँ

इमेज बन जाने के बाद, निम्न कमांड का उपयोग करके इसे कंटेनर के रूप में चलाएँ:

docker run -p 5000:5000 ml-flask-appसंचालित द्वारा

यह कमांड ml-flask-app इमेज से कंटेनर शुरू करता है। -p 5000:5000 फ़्लैग आपकी लोकल मशीन के 5000 पोर्ट को कंटेनर के 5000 पोर्ट से मैप करता है, जिससे आप ब्राउज़र या curl जैसे टूल से Flask ऐप एक्सेस कर सकें।

चरण 3: कंटेनराइज़्ड एप्लिकेशन का परीक्षण करें

एक नया टर्मिनल विंडो खोलें और कंटेनर के अंदर चल रहे Flask ऐप को टेस्ट रिक्वेस्ट भेजें:

curl -X POST -H "Content-Type: application/json" -d '{"input": [5.1, 3.5, 1.4, 0.2]}' http://localhost:5000/predictसंचालित द्वारा

आपको ऐसा रिस्पॉन्स दिखना चाहिए:

{
  "prediction": 0
}संचालित द्वारा

इसका मतलब कंटेनराइज़्ड Flask ऐप सफलतापूर्वक चल रहा है और प्रीडिक्शंस सर्व करने के लिए तैयार है।

आम समस्याओं का डीबग करना

यदि कंटेनर को बनाते या चलाते समय समस्याएँ आएँ, तो ये टिप्स मदद करेंगी:

Docker लॉग्स देखें:चल रहे कंटेनर के लॉग्स देखने के लिए यह कमांड उपयोग करें:

docker logs <container_id>संचालित द्वारा

Dockerfile सिंटैक्स जाँचें:Dockerfile में टाइपो या सिंटैक्स एरर दोबारा जाँचें।

पोर्ट कॉन्फ्लिक्ट्स जाँचें:सुनिश्चित करें कि आपकी लोकल मशीन पर 5000 पोर्ट पहले से उपयोग में न हो। यदि है, तो आप अलग पोर्ट पर मैप कर सकते हैं, जैसे:

docker run -p 5001:5000 ml-flask-appसंचालित द्वारा

इमेज को रीबिल्ड करें:

यदि आपने Dockerfile या एप्लिकेशन कोड में बदलाव किए हैं, तो यह कमांड उपयोग कर इमेज रीबिल्ड करें:

docker build -t ml-flask-app .संचालित द्वारा

अब जब हमने सफलतापूर्वक अपना Docker कंटेनर बना और टेस्ट कर लिया है, अगला कदम कंटेनराइज़्ड एप्लिकेशन को मैनेज और स्केल करना सीखना है। अगले सेक्शन में, हम देखेंगे कि Kubernetes का उपयोग करके अपने ML एप्लिकेशन को कैसे डिप्लॉय और स्केल करें।

और Docker प्रोजेक्ट्स देखें हमारे गाइड में 10 Docker प्रोजेक्ट आइडियाज़: शुरुआती से उन्नत तक।

अपने कंटेनराइज़्ड एप्लिकेशन को चलाना

अब जब हमने अपना Docker कंटेनर बना लिया है, तो आइए देखें इसे प्रभावी ढंग से कैसे मैनेज करें। यह सेक्शन कंटेनर्स को स्टार्ट, स्टॉप और इंस्पेक्ट करने के लिए जरूरी Docker कमांड्स, साथ ही लॉग्स और पोर्ट्स के साथ काम करना, समझाएगा।

कंटेनर्स को मैनेज करने के लिए Docker का उपयोग

Docker कंटेनर्स को मैनेज करने के लिए शक्तिशाली कमांड्स का सेट प्रदान करता है। आइए सबसे आमतौर पर उपयोग होने वाली कमांड्स देखें।

कंटेनर शुरू करना

किसी इमेज से कंटेनर शुरू करने के लिए docker run कमांड का उपयोग करें। उदाहरण:

docker run -p 5000:5000 ml-flask-appसंचालित द्वारा

यह कमांड ml-flask-app इमेज से कंटेनर शुरू करती है और आपकी लोकल मशीन के 5000 पोर्ट को कंटेनर के 5000 पोर्ट से मैप करती है।

यदि आप कंटेनर को बैकग्राउंड (डिटैच्ड मोड) में चलाना चाहते हैं, तो -d फ्लैग जोड़ें:

docker run -d -p 5000:5000 ml-flask-appसंचालित द्वारा

यह कंटेनर को बैकग्राउंड में चलने देता है और आपका टर्मिनल फ्री हो जाता है।

कंटेनर रोकना

चल रहे कंटेनर को रोकने के लिए, पहले इसका कंटेनर ID ढूँढें:

docker psसंचालित द्वारा

यह सभी चल रहे कंटेनर्स की सूची उनके IDs, नाम और अन्य विवरण सहित देता है। कंटेनर ID मिलने के बाद, इसे रोकें:

docker stop <container_id>संचालित द्वारा

उदाहरण:

docker stop a1b2c3d4e5f6संचालित द्वारा

कंटेनर इंस्पेक्ट करना

किसी कंटेनर की विस्तृत जानकारी देखने के लिए docker inspect कमांड का उपयोग करें:

docker inspect <container_id>संचालित द्वारा

यह JSON आउटपुट देता है जिसमें कंटेनर की नेटवर्क सेटिंग्स, माउंटेड वॉल्यूम्स, और एनवायरनमेंट वेरिएबल्स जैसी डिटेल्स होती हैं।

कंटेनर्स की सूची

सभी कंटेनर्स (चल रहे और रुके हुए) देखने के लिए उपयोग करें:

docker ps -aसंचालित द्वारा

यह आपके कंटेनरों की स्थिति जाँचने और कंटेनर IDs ढूँढने में उपयोगी है।

लॉग्स और पोर्ट्स के साथ काम करना

लॉग्स और पोर्ट्स डीबगिंग और हमारे कंटेनराइज़्ड एप्लिकेशन को एक्सेस करने के लिए महत्वपूर्ण हैं। आइए देखें इनके साथ कैसे काम करें।

कंटेनर लॉग्स देखना

चल रहे कंटेनर के लॉग्स देखने के लिए:

docker logs <container_id>संचालित द्वारा

उदाहरण:

docker logs a1b2c3d4e5f6संचालित द्वारा

यह आपके एप्लिकेशन का आउटपुट दिखाता है, जिसमें कंसोल पर प्रिंट हुए एरर या मैसेज शामिल होते हैं। यदि आप रियल-टाइम में लॉग्स फॉलो करना चाहते हैं (जैसे tail -f), तो -f फ्लैग जोड़ें:

docker logs -f <container_id>संचालित द्वारा

पोर्ट मैपिंग

कंटेनर चलाते समय, आप -p फ्लैग का उपयोग करके कंटेनर पोर्ट्स को अपनी लोकल मशीन से मैप कर सकते हैं। उदाहरण:

docker run -p 5000:5000 ml-flask-appसंचालित द्वारा

यह कंटेनर के 5000 पोर्ट को आपकी लोकल मशीन के 5000 पोर्ट से मैप करता है। यदि 5000 पोर्ट पहले से उपयोग में है, तो आप इसे अलग पोर्ट से मैप कर सकते हैं, जैसे:

docker run -p 5001:5000 ml-flask-appसंचालित द्वारा

अब आपका Flask ऐप http://localhost:5001 पर उपलब्ध होगा।

पोर्ट बाइंडिंग्स जाँचना

चल रहे कंटेनर के लिए कौन से पोर्ट मैप हुए हैं, यह देखने के लिए उपयोग करें:

docker port <container_id>संचालित द्वारा

यह कंटेनर के पोर्ट मैपिंग्स सूचीबद्ध करता है, जो कनेक्टिविटी समस्याओं के डीबग के लिए सहायक है। अगले सेक्शन में, हम देखेंगे कि अपने कंटेनराइज़्ड ML एप्लिकेशन को Kubernetes पर कैसे डिप्लॉय करें और बड़े पैमाने पर मैनेज करें।

Kubernetes के साथ स्केलिंग

जब हमारा एप्लिकेशन कंटेनराइज़ हो जाए, तो हम इसे Kubernetes का उपयोग करके डिप्लॉय कर सकते हैं। Kubernetes कंटेनराइज़्ड एप्लिकेशनों के डिप्लॉयमेंट, स्केलिंग और मैनेजमेंट को ऑटोमेट करता है, जिससे बड़े पैमाने के वर्कलोड्स संभालना आसान होता है। इस सेक्शन में, हम अपने ML एप्लिकेशन को Kubernetes क्लस्टर पर डिप्लॉय करना देखेंगे।

Kubernetes पर कंटेनर्स डिप्लॉय करना

Kubernetes आपके एप्लिकेशन की इच्छित स्थिति को परिभाषित करने के लिए YAML फ़ाइलों का उपयोग करता है। ये फ़ाइलें बताती हैं कि आपके कंटेनर्स को कैसे डिप्लॉय, स्केल और मैनेज किया जाना चाहिए। आइए अपने Flask-आधारित ML एप्लिकेशन के लिए एक Kubernetes डिप्लॉयमेंट बनाकर शुरू करें।

चरण 1: Kubernetes डिप्लॉयमेंट YAML फ़ाइल लिखें

ml-flask-app-deployment.yaml नाम से एक फ़ाइल बनाएँ और निम्न कंटेंट जोड़ें:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ml-flask-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: ml-flask-app
  template:
    metadata:
      labels:
        app: ml-flask-app
    spec:
      containers:
      - name: ml-flask-app
        image: ml-flask-app
        ports:
        - containerPort: 5000संचालित द्वारा

यह YAML फ़ाइल परिभाषित करती है:

• एक ml-flask-app नाम का डिप्लॉयमेंट।
• एप्लिकेशन के तीन रेप्लिकाज, उच्च उपलब्धता सुनिश्चित करने के लिए।
• पहले से बनी ml-flask-app इमेज का उपयोग करने वाला कंटेनर।
• 5000 का containerPort, जिस पर हमारा Flask ऐप सुनता है।

चरण 2: एप्लिकेशन डिप्लॉय करें

एप्लिकेशन को Kubernetes पर डिप्लॉय करने के लिए kubectl apply कमांड का उपयोग करें:

kubectl apply -f ml-flask-app-deployment.yamlसंचालित द्वारा

यह कमांड Kubernetes को YAML फ़ाइल में परिभाषित संसाधनों को बनाने के लिए कहता है। डिप्लॉयमेंट की स्थिति जाँचने के लिए उपयोग करें:

kubectl get deploymentsसंचालित द्वारा

यह आपके डिप्लॉयमेंट की स्थिति दिखाता है, जिसमें चल रहे रेप्लिकाज की संख्या शामिल है।

चरण 3: एप्लिकेशन एक्सपोज़ करें

Kubernetes क्लस्टर के बाहर से एप्लिकेशन को एक्सेसिबल बनाने के लिए, एक सर्विस बनाएं। ml-flask-app-service.yaml नाम से फ़ाइल बनाएँ और निम्न कंटेंट जोड़ें:

apiVersion: v1
kind: Service
metadata:
  name: ml-flask-app-service
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 5000
  selector:
    app: ml-flask-appसंचालित द्वारा

यह YAML फ़ाइल परिभाषित करती है:

• ml-flask-app-service नाम की सर्विस।
• LoadBalancer प्रकार, जो एप्लिकेशन को इंटरनेट पर एक्सपोज़ करता है।
• पोर्ट 80 (एक्सटर्नल) से पोर्ट 5000 (इंटरनल) तक मैपिंग।

सर्विस अप्लाई करें:

kubectl apply -f ml-flask-app-service.yamlसंचालित द्वारा

सर्विस की स्थिति जाँचने के लिए:

kubectl get servicesसंचालित द्वारा

यह वह एक्सटर्नल IP दिखाती है जहाँ आपका एप्लिकेशन एक्सेसिबल है।

स्केलिंग और मॉनिटरिंग

Kubernetes आपके एप्लिकेशन को स्केल करना और उसके परफॉर्मेंस की मॉनिटरिंग सरल बनाता है। आइए देखें कैसे।

एप्लिकेशन को स्केल करना

एप्लिकेशन स्केल करने के लिए, डिप्लॉयमेंट में रेप्लिकाज की संख्या अपडेट करें। उदाहरण के लिए, 5 रेप्लिकाज तक स्केल करने के लिए चलाएँ:

kubectl scale deployment ml-flask-app --replicas=5संचालित द्वारा

आप YAML फ़ाइल में replicas फ़ील्ड भी अपडेट कर सकते हैं और उसे दोबारा अप्लाई कर सकते हैं:

spec:
  replicas: 5संचालित द्वारा

फिर चलाएँ:

kubectl apply -f ml-flask-app-deployment.yamlसंचालित द्वारा

एप्लिकेशन मॉनिटर करना

Kubernetes हमारे एप्लिकेशन की मॉनिटरिंग के लिए कई टूल्स प्रदान करता है। आइए कुछ टूल्स देखें जिनसे हम मॉनिटरिंग कर सकते हैं।

किसी विशेष पॉड के लॉग्स देखने के लिए kubectl logs का उपयोग करें:

kubectl logs <pod_name>
 संचालित द्वारा

अपने पॉड्स की स्थिति जाँचने के लिए kubectl get pods का उपयोग करें:

kubectl get podsसंचालित द्वारा

CPU और मेमोरी उपयोग देखने के लिए kubectl top का उपयोग करें:

kubectl top podsसंचालित द्वारा

ऑटोस्केलिंग

Kubernetes Horizontal Pod Autoscaler (HPA) भी सपोर्ट करता है, जो CPU या मेमोरी उपयोग के आधार पर पॉड्स की संख्या अपने-आप स्केल करता है। ऑटोस्केलिंग सक्षम करने के लिए चलाएँ:

kubectl autoscale deployment ml-flask-app --cpu-percent=50 --min=3 --max=10संचालित द्वारा

यह सुनिश्चित करता है कि CPU उपयोग के आधार पर डिप्लॉयमेंट 3 से 10 रेप्लिकाज के बीच स्केल हो।

Kubernetes डिप्लॉयमेंट्स के लिए श्रेष्ठ प्रथाएँ

Kubernetes पर एप्लिकेशनों को डिप्लॉय करते समय इन श्रेष्ठ प्रथाओं का पालन करें।

रिसोर्स लिमिट्स का उपयोग करें

रिसोर्स एग्ज़ॉशन रोकने के लिए अपने कंटेनर्स के CPU और मेमोरी लिमिट्स निर्धारित करें:

resources:
   limits:
     cpu: "1"
     memory: "512Mi"संचालित द्वारा

लाइवनैस और रेडीनेस प्रोब्स का उपयोग करें

हेल्थ चेक्स जोड़ें ताकि सुनिश्चित हो कि आपका एप्लिकेशन सही से चल रहा है:

livenessProbe:
  httpGet:
    path: /health
    port: 5000
  initialDelaySeconds: 5
  periodSeconds: 10
readinessProbe:
  httpGet:
    path: /ready
    port: 5000
  initialDelaySeconds: 5
  periodSeconds: 10
   संचालित द्वारा

नेमस्पेसेज़ का उपयोग करें

कॉनफ़्लिक्ट्स से बचने के लिए अपने संसाधनों को नेमस्पेसेज़ के जरिए व्यवस्थित करें:

kubectl create namespace ml-app
kubectl apply -f ml-flask-app-deployment.yaml -n ml-appसंचालित द्वारा

अगले सेक्शन में, हम Dockerfiles को ऑप्टिमाइज़ करने, डिपेंडेंसीज़ मैनेज करने और सुरक्षा सुनिश्चित करने के टिप्स कवर करेंगे।

ML एप्लिकेशनों को कंटेनराइज़ करने के लिए श्रेष्ठ प्रथाएँ

मशीन लर्निंग एप्लिकेशनों को कंटेनराइज़ करने के अपने ही चुनौतियाँ होती हैं, जैसे बड़ी डिपेंडेंसीज़ मैनेज करना, पुनरुत्पादन सुनिश्चित करना और सुरक्षा बनाए रखना। यहाँ कुछ श्रेष्ठ प्रथाएँ हैं जो आपको इन चुनौतियों को पार करने और मजबूत कंटेनराइज़्ड ML एप्लिकेशन बनाने में मदद करेंगी।

Dockerfiles को ऑप्टिमाइज़ करना

अच्छा ऑप्टिमाइज़्ड Dockerfile बिल्ड टाइम और इमेज साइज को काफी कम कर सकता है। यहाँ कुछ टिप्स हैं:

मल्टी-स्टेज बिल्ड्स का उपयोग करें

मल्टी-स्टेज बिल्ड्स हमें एक ही Dockerfile में कई FROM स्टेटमेंट्स उपयोग करने देते हैं। इससे इंटरमीडिएट स्टेजेज़ से अनावश्यक फ़ाइलें और डिपेंडेंसीज़ हटाकर अंतिम इमेज का आकार कम होता है। उदाहरण:

# Stage 1: Build the application
FROM python:3.9-slim as builder

WORKDIR /app
COPY requirements.txt .
RUN pip install --user -r requirements.txt

COPY . .

# Stage 2: Create the final image
FROM python:3.9-slim

WORKDIR /app
COPY --from=builder /root/.local /root/.local
COPY --from=builder /app .

ENV PATH=/root/.local/bin:$PATH
EXPOSE 5000
CMD ["python", "app.py"]संचालित द्वारा

यह Dockerfile:

• डिपेंडेंसीज़ इंस्टॉल करने और एप्लिकेशन बिल्ड करने के लिए builder स्टेज का उपयोग करता है।
• केवल जरूरी फ़ाइलें (जैसे इंस्टॉल्ड डिपेंडेंसीज़ और एप्लिकेशन कोड) अंतिम इमेज में कॉपी करता है, जिससे साइज कम होता है।

लेयर्स कम करें

Dockerfile की हर इंस्ट्रक्शन एक नई लेयर बनाती है। लेयर्स की संख्या और इमेज साइज कम करने के लिए:

• कई RUN कमांड्स को && के साथ एक कमांड में जोड़ें।
• जब तक ADD की अतिरिक्त फ़ंक्शनैलिटी न चाहिए हो, COPY का उपयोग करें।

उदाहरण:

RUN apt-get update && \
    apt-get install -y --no-install-recommends build-essential && \
    rm -rf /var/lib/apt/lists/*संचालित द्वारा

हल्की बेस इमेज का उपयोग करें

python:3.9-slim जैसी हल्की बेस इमेज चुनें, python:3.9 जैसी बड़ी इमेज की बजाय। स्लिम इमेज में केवल जरूरी पैकेज होते हैं, जिससे कुल इमेज साइज घटता है।

डिपेंडेंसीज़ और पुनरुत्पादकता मैनेज करना

मशीन लर्निंग वर्कफ़्लोज़ में पुनरुत्पादकता अहम है। यहाँ बताया गया है कि डिपेंडेंसीज़ कैसे मैनेज करें और अपने कंटेनराइज़्ड एप्लिकेशनों में पुनरुत्पादकता कैसे सुनिश्चित करें।

requirements.txt या pipenv का उपयोग करें

अपनी सभी Python डिपेंडेंसीज़ को requirements.txt फ़ाइल में सूचीबद्ध करें या उन्हें मैनेज करने के लिए pipenv का उपयोग करें। उदाहरण:

# requirements.txt
scikit-learn==1.3.0
numpy==1.24.3
Flask==2.3.2संचालित द्वारा

Dockerfile में डिपेंडेंसीज़ इंस्टॉल करें:

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txtसंचालित द्वारा

डिपेंडेंसी वर्ज़न पिन करें

हमेशा डिपेंडेंसीज़ के वर्ज़न पिन करें ताकि अप्रत्याशित बदलाव न हों। उदाहरण:

scikit-learn==1.3.0
numpy==1.24.3
Flask==2.3.2संचालित द्वारा

कॉनफ़िगरेशन के लिए एनवायरनमेंट वेरिएबल्स का उपयोग करें

एप्लिकेशन को हार्डकोड करने की बजाय एनवायरनमेंट वेरिएबल्स से कॉन्फ़िगर करें। इससे आपका कंटेनर अधिक लचीला बनता है और अलग-अलग वातावरणों में कॉन्फ़िगर करना आसान होता है। उदाहरण:

ENV MODEL_PATH=/app/models/model.pklसंचालित द्वारा

फिर, अपने एप्लिकेशन में एनवायरनमेंट वेरिएबल एक्सेस करें:

import os
model_path = os.getenv('MODEL_PATH')संचालित द्वारा

सुरक्षा संबंधी विचार

सुरक्षा कंटेनराइज़्ड एप्लिकेशनों का एक अहम पहलू है। अपने ML एप्लिकेशनों को सुरक्षित रखने की कुछ श्रेष्ठ प्रथाएँ यहाँ दी गई हैं:

root के रूप में रन करने से बचें

कंटेनर्स को root यूज़र के रूप में चलाना सुरक्षा जोखिम पैदा कर सकता है। इसके बजाय, एक नॉन-रूट यूज़र बनाएँ और कंटेनर को उसी के रूप में चलाएँ। उदाहरण:

# Create a non-root user
RUN useradd -m myuser

# Switch to the non-root user
USER myuser

# Set the working directory
WORKDIR /home/myuser/app

# Copy the application code
COPY --chown=myuser:myuser . .

# Run the application
CMD ["python", "app.py"]संचालित द्वारा

इमेजेज़ को कमजोरियों के लिए स्कैन करें

Trivy या Clair जैसे टूल्स का उपयोग करके अपनी Docker इमेजेज़ को कमजोरियों के लिए स्कैन करें। उदाहरण के लिए, Trivy से किसी इमेज को स्कैन करने के लिए:

trivy image ml-flask-appसंचालित द्वारा

सीक्रेट्स को सुरक्षित रूप से मैनेज करें

API keys या डेटाबेस क्रेडेंशियल्स जैसी संवेदनशील जानकारी को अपने Dockerfile या एप्लिकेशन कोड में कभी हार्डकोड न करें। इसके बजाय, Kubernetes Secrets या Docker Secrets का उपयोग करें। उदाहरण, Kubernetes में:

apiVersion: v1
kind: Secret
metadata:
  name: my-secret
type: Opaque
data:
  api_key: <base64-encoded-api-key>संचालित द्वारा

फिर, अपने डिप्लॉयमेंट में सीक्रेट को एनवायरनमेंट वेरिएबल के रूप में माउंट करें:

env:
- name: API_KEY
  valueFrom:
    secretKeyRef:
      name: my-secret
      key: api_keyसंचालित द्वारा

टेस्टिंग और डीबगिंग

यह सुनिश्चित करने के लिए कि आपका कंटेनराइज़्ड एप्लिकेशन अपेक्षा के अनुरूप काम करता है, टेस्टिंग और डीबगिंग जरूरी हैं। कुछ टिप्स:

लोकली टेस्ट करें

Kubernetes पर डिप्लॉय करने से पहले, Docker का उपयोग करके लोकली अपने कंटेनर को टेस्ट करें। उदाहरण:

docker run -p 5000:5000 ml-flask-appसंचालित द्वारा

डीबगिंग के लिए लॉग्स का उपयोग करें

अपने कंटेनराइज़्ड एप्लिकेशन में समस्याएँ डीबग करने के लिए docker logs या kubectl logs का उपयोग करें। उदाहरण:

docker logs <container_id>
kubectl logs <pod_name>संचालित द्वारा

टेस्टिंग को ऑटोमेट करें

अपने कंटेनराइज़्ड एप्लिकेशनों की टेस्टिंग और डिप्लॉयमेंट को ऑटोमेट करने के लिए CI/CD पाइपलाइन्स का उपयोग करें। GitHub Actions, GitLab CI, या Jenkins जैसे टूल्स हमें ऑटोमेटेड वर्कफ़्लोज़ सेट करने में मदद करते हैं।

इन श्रेष्ठ प्रथाओं का पालन करके, हम कुशल, पुनरुत्पाद्य और सुरक्षित कंटेनराइज़्ड मशीन लर्निंग एप्लिकेशन बना सकते हैं। Dockerfiles को ऑप्टिमाइज़ करने से लेकर डिपेंडेंसीज़ मैनेज करने और सुरक्षा सुनिश्चित करने तक, ये रणनीतियाँ हमारे ML वर्कफ़्लोज़ को सुव्यवस्थित करने और आत्मविश्वास के साथ मॉडल्स डिप्लॉय करने में मदद करेंगी।

निष्कर्ष

Docker और Kubernetes के साथ मशीन लर्निंग एप्लिकेशनों को कंटेनराइज़ करना डिप्लॉयमेंट को सरल बनाता है, पुनरुत्पादकता सुनिश्चित करता है, और स्केलेबिलिटी बढ़ाता है। Dockerfiles को ऑप्टिमाइज़ करने, डिपेंडेंसीज़ मैनेज करने और सुरक्षा को प्राथमिकता देने जैसी श्रेष्ठ प्रथाओं का पालन करके, हम मजबूत, कुशल और सुरक्षित ML वर्कफ़्लोज़ बना सकते हैं।

कंटेनराइज़ेशन के बारे में सीखना जारी रखने और अपने मशीन लर्निंग वर्कफ़्लोज़ को बेहतर बनाने के लिए, ये कोर्स देखें:

• Introduction to Docker कोर्स
• Intermediate Docker कोर्स
• Introduction to Kubernetes कोर्स
• Docker for Data Science: एक परिचय
• Python में मशीन लर्निंग साइंटिस्ट बनें
• Machine Learning Fundamentals in Python ट्रैक