Cara Mewadahkah Aplikasi Menggunakan Docker

Seiring aplikasi pembelajaran mesin menjadi semakin kompleks, membawa model pembelajaran mesin dari pengembangan ke produksi tidak hanya soal menulis kode yang baik. Ini juga tentang memastikan aplikasi berjalan konsisten di berbagai lingkungan. Di sinilah kontainerisasi berperan. Namun, sebenarnya apa itu kontainerisasi, dan mengapa ini menjadi pengubah permainan bagi alur kerja pembelajaran mesin?

Kontainerisasi adalah cara yang ringan dan portabel untuk mengemas sebuah aplikasi beserta semua dependensi, pustaka, dan konfigurasinya ke dalam satu unit yang disebut kontainer. Berbeda dengan mesin virtual (VM) tradisional, kontainer berbagi sistem operasi host, sehingga lebih cepat, lebih efisien, dan lebih mudah diskalakan. 

Bagi data scientist dan insinyur ML, ini berarti Anda dapat membangun model di mesin lokal dan menerapkannya di mana saja, baik di platform cloud, server, maupun laptop rekan kerja, tanpa khawatir masalah kompatibilitas.

Dalam tutorial ini, kita akan melihat cara mengontainerkan aplikasi pembelajaran mesin menggunakan Docker dan Kubernetes. Pada akhir tutorial, Anda akan mengetahui cara:

1. Membangun kontainer Docker untuk aplikasi ML Anda.
2. Menerapkan dan mengelola aplikasi yang dikontainerkan menggunakan Kubernetes.
3. Melakukan penskalaan dan pemantauan aplikasi ML Anda di lingkungan produksi.

Jika Anda baru mengenal Docker, lihat panduan kami tentang Cara Belajar Docker dari Nol. Anda juga dapat mengikuti kursus kami, Kontainerisasi dan Virtualisasi dengan Docker dan Kubernetes.  

Prasyarat

Sebelum mulai, Anda sebaiknya memahami dasar-dasar Python, alur kerja pembelajaran mesin, dan penggunaan command line. Keakraban dengan konsep Docker (mis., image, container, perintah dasar) direkomendasikan, dan pengetahuan dasar Kubernetes bersifat opsional namun membantu untuk penerapan dan penskalaan. 

Apa itu Aplikasi yang Dikontainerkan?

Aplikasi yang dikontainerkan adalah aplikasi perangkat lunak yang dikemas bersama semua dependensi, pustaka, dan konfigurasinya ke dalam satu unit ringan yang disebut kontainer. Untuk aplikasi pembelajaran mesin, ini berarti mengemas segala sesuatu mulai dari model terlatih hingga pustaka Python yang menjadi dependensinya, sehingga aplikasi Anda berjalan dengan cara yang sama di mana pun.

Aplikasi tradisional versus aplikasi yang dikontainerkan

Mengapa kontainerisasi penting untuk aplikasi pembelajaran mesin

Saat mengembangkan aplikasi pembelajaran mesin, Anda mungkin pernah menemui masalah "berfungsi di mesin saya". Mungkin model berjalan sempurna di laptop Anda tetapi gagal saat diterapkan ke cloud, atau rekan tidak dapat mereproduksi hasil Anda karena mereka menginstal versi scikit-learn atau TensorFlow yang berbeda. 

Kontainerisasi menyelesaikan masalah ini dengan menciptakan lingkungan yang konsisten dan terisolasi untuk aplikasi Anda. Berikut yang membuat aplikasi terkontainer lebih baik untuk pembelajaran mesin:

1. Konsistensi: Aplikasi Anda berperilaku sama di berbagai lingkungan—dari pengembangan, pengujian, hingga produksi.
2. Isolasi: Setiap kontainer berjalan di lingkungannya sendiri, mencegah konflik antar aplikasi atau dependensi yang berbeda.
3. Portabilitas: Kontainer dapat berjalan di platform apa pun yang mendukung kontainerisasi, baik mesin lokal Anda, layanan cloud, maupun server on-premise.
4. Skalabilitas: Perlu menangani lebih banyak permintaan? Kontainer memudahkan penskalaan aplikasi Anda secara horizontal dengan menjalankan beberapa instans.

Kontainer vs mesin virtual

Meskipun kontainer dan mesin virtual (VM) sama-sama digunakan untuk mengisolasi aplikasi, keduanya berbeda secara signifikan dalam cara beroperasi dan kasus penggunaannya. Berikut ringkasan perbedaan dan keunggulan utamanya:

Untuk aplikasi pembelajaran mesin, perbedaan ini penting. Saat Anda perlu menskalakan model untuk menangani lebih banyak prediksi, atau ketika ingin menerapkan beberapa versi model untuk A/B testing, kontainer memberikan kelincahan dan efisiensi sumber daya yang Anda perlukan.

Untuk mempelajari lebih lanjut tentang kontainerisasi dan virtualisasi, lihat jalur pembelajaran ini: Kontainerisasi dan Virtualisasi dengan Docker dan Kubernetes.

Cara Mengontainerkan Aplikasi Pembelajaran Mesin 

Pada bagian di bawah ini, kami menguraikan panduan langkah demi langkah tentang cara mengontainerkan sebuah aplikasi: 

1. Menyiapkan lingkungan Anda

Sebelum mulai mengontainerkan aplikasi pembelajaran mesin, kita perlu menyiapkan alat yang diperlukan dan menyiapkan lingkungan. Bagian ini akan memandu Anda memasang Docker dan menyiapkan aplikasi pembelajaran mesin sederhana untuk dikontainerkan.

Alat yang Anda perlukan

Untuk mengontainerkan aplikasi pembelajaran mesin, Anda memerlukan alat berikut:

1. Docker: Platform untuk membangun, mengirim, dan menjalankan kontainer.
2. Kubernetes (opsional): Alat orkestrasi untuk mengelola kontainer dalam skala besar. (Akan dibahas nanti dalam tutorial.)

Mari mulai dengan memasang Docker.

Langkah 1: Memasang Docker

Docker tersedia untuk Windows, macOS, dan Linux. Di bawah ini adalah langkah-langkah untuk memasang Docker di sistem Anda.

Untuk Windows/macOS:

1. Kunjungi situs Docker.
2. Unduh dan pasang Docker Desktop.
3. Ikuti petunjuk pemasangan yang disediakan oleh installer.

Untuk Linux (Ubuntu/Debian):

Buka terminal Anda dan jalankan perintah berikut untuk memasang 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

Proses pemasangan ini menambahkan repositori Docker ke sistem Anda, memverifikasi keasliannya dengan kunci GPG, dan memasang mesin Docker beserta alat baris perintahnya.

Langkah 2: Verifikasi pemasangan Docker 

Setelah Docker terpasang, verifikasi bahwa ia berfungsi dengan baik dengan menjalankan perintah berikut di command prompt:

# Check Docker version
docker --version

# Run hello-world container
docker run hello-world

Perintah ini menarik image uji ringan dan menjalankannya sebagai kontainer. Jika berhasil, Anda akan melihat pesan sambutan yang menegaskan pemasangan berfungsi dengan baik, seperti berikut:

Hello from Docker!

2. Menyiapkan aplikasi pembelajaran mesin Anda

Sekarang Docker sudah terpasang, mari siapkan aplikasi pembelajaran mesin sederhana untuk dikontainerkan. Untuk tutorial ini, kita akan menggunakan skrip Python dasar yang memuat model terlatih dan menyajikan prediksi melalui API Flask.

Langkah 1: Buat Aplikasi ML Sederhana

Buat direktori baru untuk proyek Anda dan tambahkan berkas berikut:

1. app.py: Skrip Python untuk menyajikan prediksi melalui API Flask.
2. requirements.txt: Berkas yang mencantumkan dependensi Python.

Berikut kode untuk 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)

Kode memuat dataset Iris, melatih classifier Random Forest, dan menyiapkan endpoint API Flask yang menerima nilai fitur dan mengembalikan prediksi. Kita membangunnya sebagai layanan web agar cocok untuk dikontainerkan.

Langkah 2: Buat requirements.txt

Berkas requirements.txt mencantumkan pustaka Python yang diperlukan untuk menjalankan skrip. Buat berkas ini di direktori yang sama dengan app.py:

# requirements.txt
scikit-learn==1.3.0
numpy==1.24.3
flask==2.0.1

Ini menentukan versi pasti paket Python yang dibutuhkan aplikasi kita. Mematok versi memastikan aplikasi yang dikontainerkan akan konsisten dan dapat direproduksi.

Kini lingkungan kita siap dan aplikasi ML sudah siap, kita bisa lanjut membangun kontainer Docker pertama. Pada bagian berikutnya, kita akan menulis Dockerfile dan membangun image Docker untuk aplikasi ML berbasis Flask kita.

3. Membangun kontainer Docker pertama Anda

Sekarang aplikasi pembelajaran mesin kita siap, langkah berikutnya adalah mengontainerkannya menggunakan Docker. Ini melibatkan pembuatan Dockerfile, yaitu skrip yang berisi instruksi untuk membangun image Docker. Setelah image dibuat, kita dapat menjalankannya sebagai kontainer.

Contoh Dockerfile: Menulis Dockerfile

Sebuah Dockerfile adalah dokumen teks yang berisi semua perintah untuk menyusun sebuah image. Berikut cara membuatnya untuk aplikasi ML berbasis Flask kita.

1. Di direktori yang sama dengan app.py dan requirements.txt, buat berkas baru bernama Dockerfile (tanpa ekstensi berkas).
2. Tambahkan konten berikut ke 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"]

Penjelasan:

• FROM python:3.9-slim: Kita menggunakan image resmi Python 3.9 versi slim sebagai image dasar. Versi slim ringan dan ideal untuk aplikasi yang dikontainerkan.
• WORKDIR /app: Menetapkan direktori kerja di dalam kontainer ke /app. Semua perintah berikutnya akan dijalankan dari direktori ini.
• COPY requirements.txt .: Menyalin berkas requirements.txt dari mesin lokal Anda ke dalam kontainer.
• RUN pip install --no-cache-dir -r requirements.txt: Memasang dependensi Python yang tercantum dalam requirements.txt. Flag --no-cache-dir mengurangi ukuran image dengan tidak menyimpan cache.
• COPY . .: Menyalin semua berkas dari direktori saat ini di mesin lokal Anda ke direktori /app di dalam kontainer.
• EXPOSE 5000: Mengekspos port 5000, yaitu port yang didengarkan oleh aplikasi Flask kita.
• CMD ["python", "app.py"]: Mendefinisikan perintah untuk menjalankan aplikasi Flask saat kontainer dimulai.

Membangun dan menguji image Docker

Dengan Dockerfile siap, sekarang kita dapat membangun image Docker dan menjalankannya sebagai kontainer. 

Langkah 1: Bangun image Docker

Jalankan perintah berikut di terminal untuk membangun image Docker:

docker build -t ml-flask-app .

Perintah ini membangun image Docker dari Dockerfile di direktori saat ini. Flag -t ml-flask-app memberi tag image dengan nama ml-flask-app, sehingga lebih mudah dirujuk nanti.

Langkah 2: Jalankan kontainer Docker

Setelah image dibuat, jalankan sebagai kontainer menggunakan perintah berikut:

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

Perintah ini memulai kontainer dari image ml-flask-app. Flag -p 5000:5000 memetakan port 5000 di mesin lokal Anda ke port 5000 di dalam kontainer, memungkinkan Anda mengakses aplikasi Flask dari browser atau alat seperti curl.

Langkah 3: Uji aplikasi yang dikontainerkan

Buka jendela terminal baru dan kirim permintaan uji ke aplikasi Flask yang berjalan di dalam kontainer:

curl -X POST -H "Content-Type: application/json" -d '{"input": [5.1, 3.5, 1.4, 0.2]}' http://localhost:5000/predict

Anda akan melihat respons seperti ini:

{
  "prediction": 0
}

Ini berarti aplikasi Flask yang dikontainerkan berjalan dengan sukses dan siap menyajikan prediksi.

Debugging masalah umum

Jika Anda mengalami masalah saat membangun atau menjalankan kontainer, berikut beberapa kiat untuk membantu Anda memecahkan masalah:

Periksa log Docker:Gunakan perintah berikut untuk melihat log kontainer yang sedang berjalan:

docker logs <container_id>

Verifikasi sintaks Dockerfile:Periksa kembali Dockerfile untuk kesalahan ketik atau sintaks.

Periksa konflik port:Pastikan port 5000 tidak sedang digunakan di mesin lokal Anda. Jika ya, Anda dapat memetakan kontainer ke port berbeda, seperti ini:

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

Bangun ulang image:

Jika Anda membuat perubahan pada Dockerfile atau kode aplikasi, bangun ulang image menggunakan:

docker build -t ml-flask-app .

Sekarang kita telah berhasil membangun dan menguji kontainer Docker, langkah berikutnya adalah mempelajari cara mengelola dan menskalakan aplikasi yang dikontainerkan. Pada bagian selanjutnya, kita akan mengeksplorasi cara menggunakan Kubernetes untuk menerapkan dan menskalakan aplikasi ML kita.

Lihat lebih banyak proyek Docker dalam panduan kami 10 Ide Proyek Docker: Dari Pemula hingga Mahir.

Menjalankan Aplikasi yang Dikontainerkan

Sekarang kita telah membangun kontainer Docker, mari lihat cara mengelolanya secara efektif. Bagian ini akan memandu Anda melalui perintah Docker penting untuk memulai, menghentikan, dan menginspeksi kontainer, serta bekerja dengan log dan port.

Menggunakan Docker untuk mengelola kontainer

Docker menyediakan serangkaian perintah yang andal untuk mengelola kontainer. Mari kita bahas yang paling umum digunakan.

Memulai sebuah kontainer

Untuk memulai kontainer dari sebuah image, gunakan perintah docker run. Contohnya:

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

Perintah ini memulai kontainer dari image ml-flask-app dan memetakan port 5000 di mesin lokal Anda ke port 5000 di dalam kontainer.

Jika Anda ingin menjalankan kontainer di latar belakang (mode detached), tambahkan flag -d:

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

Ini memungkinkan kontainer berjalan di latar belakang, sehingga terminal Anda bebas.

Menghentikan sebuah kontainer

Untuk menghentikan kontainer yang sedang berjalan, pertama temukan ID kontainernya menggunakan:

docker ps

Ini menampilkan semua kontainer yang berjalan beserta ID, nama, dan detail lainnya. Setelah Anda memiliki ID kontainer, hentikan kontainer dengan:

docker stop <container_id>

Contohnya:

docker stop a1b2c3d4e5f6

Menginspeksi sebuah kontainer

Untuk melihat informasi detail tentang sebuah kontainer, gunakan perintah docker inspect:

docker inspect <container_id>

Ini memberikan keluaran JSON dengan detail seperti pengaturan jaringan kontainer, volume yang di-mount, dan variabel lingkungan.

Mendaftar kontainer

Untuk melihat semua kontainer (baik yang berjalan maupun berhenti), gunakan:

docker ps -a

Ini berguna untuk memeriksa status kontainer Anda dan menemukan ID kontainer.

Bekerja dengan log dan port

Log dan port sangat penting untuk debugging dan mengakses aplikasi yang dikontainerkan. Mari jelajahi cara bekerja dengannya.

Melihat log kontainer

Untuk melihat log kontainer yang sedang berjalan, gunakan:

docker logs <container_id>

Contohnya:

docker logs a1b2c3d4e5f6

Ini menampilkan keluaran aplikasi Anda, termasuk kesalahan atau pesan yang dicetak ke konsol. Jika Anda ingin mengikuti log secara real-time (seperti tail -f), tambahkan flag -f:

docker logs -f <container_id>

Memetakan port

Saat menjalankan kontainer, Anda dapat memetakan port kontainer ke mesin lokal menggunakan flag -p. Contohnya:

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

Ini memetakan port 5000 di dalam kontainer ke port 5000 di mesin lokal Anda. Jika port 5000 sudah digunakan, Anda dapat memetakan ke port lain, seperti ini:

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

Sekarang, aplikasi Flask Anda dapat diakses di http://localhost:5001.

Memeriksa binding port

Untuk melihat port mana yang dipetakan ke kontainer yang berjalan, gunakan:

docker port <container_id>

Ini menampilkan pemetaan port untuk kontainer, yang membantu untuk debugging masalah konektivitas. Pada bagian berikutnya, kita akan melihat cara menerapkan aplikasi ML yang dikontainerkan pada Kubernetes dan mengelolanya dalam skala besar.

Penskalaan dengan Kubernetes

Setelah aplikasi kita dikontainerkan, kita dapat menerapkannya menggunakan Kubernetes. Kubernetes mengotomatisasi penerapan, penskalaan, dan pengelolaan aplikasi yang dikontainerkan, sehingga lebih mudah menangani beban kerja skala besar. Pada bagian ini, kita akan melihat cara menerapkan aplikasi ML kita pada klaster Kubernetes.

Menerapkan kontainer di Kubernetes

Kubernetes menggunakan berkas YAML untuk mendefinisikan keadaan yang diinginkan dari aplikasi Anda. Berkas-berkas ini menjelaskan bagaimana kontainer Anda harus diterapkan, diskalakan, dan dikelola. Mari mulai dengan membuat deployment Kubernetes untuk aplikasi ML berbasis Flask kita.

Langkah 1: Tulis berkas YAML deployment Kubernetes

Buat berkas bernama ml-flask-app-deployment.yaml dengan konten berikut:

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

Berkas YAML ini mendefinisikan:

•  Sebuah Deployment bernama ml-flask-app.
• Tiga replika aplikasi, memastikan ketersediaan tinggi.
• Sebuah kontainer yang menggunakan image ml-flask-app yang kita bangun sebelumnya.
• containerPort 5000, yaitu port yang didengarkan oleh aplikasi Flask kita.

Langkah 2: Terapkan aplikasi

Untuk menerapkan aplikasi di Kubernetes, gunakan perintah kubectl apply:

kubectl apply -f ml-flask-app-deployment.yaml

Perintah ini memberi tahu Kubernetes untuk membuat sumber daya yang didefinisikan dalam berkas YAML. Anda dapat memeriksa status deployment menggunakan:

kubectl get deployments

Ini menunjukkan status deployment Anda, termasuk jumlah replika yang berjalan.

Langkah 3: Mengekspos aplikasi

Untuk membuat aplikasi dapat diakses dari luar klaster Kubernetes, buat sebuah Service. Buat berkas bernama ml-flask-app-service.yaml dengan konten berikut:

apiVersion: v1
kind: Service
metadata:
  name: ml-flask-app-service
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 5000
  selector:
    app: ml-flask-app

Berkas YAML ini mendefinisikan:

• Sebuah Service bernama ml-flask-app-service.
• Tipe LoadBalancer, yang mengekspos aplikasi ke internet.
• Pemetaan dari port 80 (eksternal) ke port 5000 (internal).

Terapkan Service menggunakan:

kubectl apply -f ml-flask-app-service.yaml

Anda dapat memeriksa status Service menggunakan:

kubectl get services

Ini menampilkan alamat IP eksternal tempat aplikasi Anda dapat diakses.

Penskalaan dan pemantauan

Kubernetes memudahkan untuk menskalakan aplikasi Anda dan memantau kinerjanya. Mari kita eksplor cara melakukannya.

Melakukan penskalaan aplikasi

Untuk menskalakan aplikasi Anda, perbarui jumlah replika dalam deployment. Misalnya, untuk menskalakan menjadi 5 replika, jalankan:

kubectl scale deployment ml-flask-app --replicas=5

Anda juga dapat memperbarui kolom replicas di file YAML dan menerapkannya kembali:

spec:
  replicas: 5

Lalu jalankan:

kubectl apply -f ml-flask-app-deployment.yaml

Memantau aplikasi

Kubernetes menyediakan beberapa alat untuk memantau aplikasi kita. Mari kita lihat beberapa alat untuk memantau aplikasi kita.

Gunakan kubectl logs untuk melihat log dari pod tertentu:

kubectl logs <pod_name>
 

Gunakan kubectl get pods untuk memeriksa status pod Anda:

kubectl get pods

Gunakan kubectl top untuk melihat penggunaan CPU dan memori:

kubectl top pods

Penskalaan otomatis

Kubernetes juga mendukung Horizontal Pod Autoscaler (HPA), yang secara otomatis menskalakan jumlah pod berdasarkan penggunaan CPU atau memori. Untuk mengaktifkan penskalaan otomatis, jalankan:

kubectl autoscale deployment ml-flask-app --cpu-percent=50 --min=3 --max=10

Ini memastikan deployment diskalakan antara 3 hingga 10 replika berdasarkan penggunaan CPU.

Praktik terbaik untuk deployment Kubernetes

Berikut beberapa praktik terbaik yang perlu diikuti saat melakukan deployment aplikasi di Kubernetes.

Gunakan batas sumber daya

Tentukan batas CPU dan memori untuk container Anda guna mencegah kehabisan sumber daya:

resources:
   limits:
     cpu: "1"
     memory: "512Mi"

Gunakan liveness dan readiness probe

Tambahkan pemeriksaan kesehatan untuk memastikan aplikasi Anda berjalan dengan benar:

livenessProbe:
  httpGet:
    path: /health
    port: 5000
  initialDelaySeconds: 5
  periodSeconds: 10
readinessProbe:
  httpGet:
    path: /ready
    port: 5000
  initialDelaySeconds: 5
  periodSeconds: 10
   

Gunakan namespace

Atur sumber daya Anda menggunakan namespace untuk menghindari konflik:

kubectl create namespace ml-app
kubectl apply -f ml-flask-app-deployment.yaml -n ml-app

Di bagian berikutnya, kita akan membahas kiat untuk mengoptimalkan Dockerfile, mengelola dependensi, dan memastikan keamanan.

Praktik Terbaik untuk Mewadahkah Aplikasi ML

Mewadahkah (containerizing) aplikasi machine learning memiliki tantangan tersendiri, seperti mengelola dependensi besar, memastikan reprodusibilitas, dan menjaga keamanan. Berikut beberapa praktik terbaik untuk membantu Anda mengatasi tantangan ini dan membangun aplikasi ML terwadahkan yang tangguh.

Mengoptimalkan Dockerfile

Dockerfile yang dioptimalkan dengan baik dapat mengurangi waktu build dan ukuran image secara signifikan. Berikut beberapa kiat untuk mengoptimalkan Dockerfile Anda:

Gunakan build multi-tahap

Build multi-tahap memungkinkan kita menggunakan beberapa pernyataan FROM dalam satu Dockerfile. Ini membantu mengurangi ukuran image final dengan membuang file dan dependensi yang tidak diperlukan dari tahap perantara. Contohnya:

# 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 ini:

• Menggunakan tahap builder untuk memasang dependensi dan membangun aplikasi.
• Hanya menyalin file yang diperlukan (misalnya, dependensi terpasang dan kode aplikasi) ke image final, sehingga ukurannya lebih kecil.

Minimalkan layer

Setiap instruksi dalam Dockerfile membuat layer baru. Untuk meminimalkan jumlah layer dan mengurangi ukuran image:

• Gabungkan beberapa perintah RUN menjadi satu perintah menggunakan &&.
• Gunakan COPY daripada ADD kecuali Anda memerlukan fungsionalitas tambahan dari ADD.

Contohnya:

RUN apt-get update && \
    apt-get install -y --no-install-recommends build-essential && \
    rm -rf /var/lib/apt/lists/*

Gunakan image basis yang ringan

Pilih image basis yang ringan seperti python:3.9-slim daripada yang lebih besar seperti python:3.9. Image slim hanya berisi paket esensial, sehingga ukuran image keseluruhan berkurang.

Mengelola dependensi dan reprodusibilitas

Reprodusibilitas sangat penting dalam alur kerja machine learning. Berikut cara mengelola dependensi dan memastikan reprodusibilitas dalam aplikasi terwadahkan Anda.

Gunakan requirements.txt atau pipenv

Daftarkan semua dependensi Python Anda dalam file requirements.txt atau gunakan pipenv untuk mengelolanya. Contohnya:

# requirements.txt
scikit-learn==1.3.0
numpy==1.24.3
Flask==2.3.2

Pasang dependensi di Dockerfile Anda:

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

Kunci versi dependensi

Selalu kunci versi dependensi Anda untuk menghindari perubahan tak terduga. Contohnya:

scikit-learn==1.3.0
numpy==1.24.3
Flask==2.3.2

Gunakan variabel lingkungan untuk konfigurasi

Gunakan variabel lingkungan untuk mengonfigurasi aplikasi alih-alih menuliskan nilai secara hardcode. Ini membuat container Anda lebih fleksibel dan mudah dikonfigurasi di berbagai lingkungan. Contohnya:

ENV MODEL_PATH=/app/models/model.pkl

Lalu, akses variabel lingkungan tersebut di aplikasi Anda:

import os
model_path = os.getenv('MODEL_PATH')

Pertimbangan keamanan

Keamanan merupakan aspek krusial dari aplikasi terwadahkan. Berikut beberapa praktik terbaik untuk mengamankan aplikasi ML Anda:

Hindari berjalan sebagai root

Menjalankan container sebagai pengguna root dapat membuka risiko keamanan pada sistem Anda. Sebagai gantinya, buat pengguna non-root dan jalankan container sebagai pengguna tersebut. Contohnya:

# 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"]

Pindai image untuk kerentanan

Gunakan alat seperti Trivy atau Clair untuk memindai image Docker Anda dari kerentanan. Misalnya, untuk memindai image dengan Trivy:

trivy image ml-flask-app

Kelola secret secara aman

Jangan pernah menuliskan informasi sensitif seperti kunci API atau kredensial basis data secara hardcode di Dockerfile atau kode aplikasi Anda. Sebagai gantinya, gunakan Kubernetes Secrets atau Docker Secrets untuk mengelola data sensitif. Contohnya, di Kubernetes:

apiVersion: v1
kind: Secret
metadata:
  name: my-secret
type: Opaque
data:
  api_key: <base64-encoded-api-key>

Kemudian, kaitkan secret tersebut sebagai variabel lingkungan di deployment Anda:

env:
- name: API_KEY
  valueFrom:
    secretKeyRef:
      name: my-secret
      key: api_key

Pengujian dan debug

Pengujian dan debug sangat penting untuk memastikan aplikasi terwadahkan Anda bekerja sesuai harapan. Berikut beberapa kiat:

Uji secara lokal

Sebelum dideploy ke Kubernetes, uji container Anda secara lokal menggunakan Docker. Contohnya:

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

Gunakan log untuk debugging

Gunakan docker logs atau kubectl logs untuk men-debug masalah pada aplikasi terwadahkan Anda. Contohnya:

docker logs <container_id>
kubectl logs <pod_name>

Otomatisasikan pengujian

Gunakan pipeline CI/CD untuk mengotomatiskan pengujian dan deployment aplikasi terwadahkan Anda. Alat seperti GitHub Actions, GitLab CI, atau Jenkins dapat membantu kita menyiapkan alur kerja otomatis.

Dengan mengikuti praktik terbaik ini, kita dapat membangun aplikasi machine learning terwadahkan yang efisien, dapat direproduksi, dan aman. Dari mengoptimalkan Dockerfile hingga mengelola dependensi dan memastikan keamanan, strategi-strategi ini akan membantu kita menyederhanakan alur kerja ML dan melakukan deployment model dengan percaya diri.

Kesimpulan

Mewadahkah aplikasi machine learning dengan Docker dan Kubernetes menyederhanakan deployment, memastikan reprodusibilitas, dan meningkatkan skalabilitas. Dengan mengikuti praktik terbaik seperti mengoptimalkan Dockerfile, mengelola dependensi, dan memprioritaskan keamanan, kita dapat membangun alur kerja ML yang tangguh, efisien, dan aman.

Untuk terus belajar tentang containerization dan meningkatkan alur kerja machine learning Anda, lihat kursus-kursus berikut:

• Kursus Introduction to Docker
• Kursus Intermediate Docker
• Kursus Introduction to Kubernetes
• Docker for Data Science: An Introduction
• Menjadi Machine Learning Scientist in Python
• Machine Learning Fundamentals in Python Track