مقدمة إلى Kubernetes للمطورين: نشر أول تطبيق خطوة بخطوة

إذا كنت كمطور بدأت تستخدم الحاويات (Containers) عبر Docker، فغالبًا ستسمع كثيرًا عن Kubernetes. هذه المنصة أصبحت المعيار الفعلي لإدارة وتشغيل التطبيقات المعتمدة على الحاويات في البيئات الكبيرة (والصغيرة أيضًا). في هذا المقال سنقدّم مقدمة عملية إلى Kubernetes للمطورين، ونشرح المفاهيم الأساسية مثل Pods, Services, Deployments، وكيف تكتب ملفات YAML بسيطة، مع مثال عملي لنشر تطبيق ويب صغير باستخدام أدوات محلية مثل Minikube وKind.

إذا لم تكن مرتاحًا بعد مع مفهوم الحاويات، يمكنك الرجوع إلى مقالنا عن تعلم الدوكر: شرح أساسيات التعامل مع الحاويات ثم العودة إلى هذه المقدمة.

ما هي Kubernetes للمطورين؟

Kubernetes (أو K8s) هي منصة مفتوحة المصدر لإدارة وتشغيل التطبيقات داخل حاويات. يمكن اعتباره نظام تشغيل لمراكز البيانات، يتولى:

• تشغيل الحاويات على مجموعة من الخوادم (Cluster).
• التعامل مع التوسع (Scaling) تلقائيًا.
• إعادة تشغيل الحاويات عند فشلها.
• توزيع الترافيك بين نسخ التطبيق (Load Balancing).
• إدارة الإعدادات والأسرار (Config & Secrets).

من منظور مطور، Kubernetes للمطورين يعني: كيف تكتب ملفات تعريف لتطبيقك (YAML)، وتتعامل مع الأوامر الأساسية، وتفهم ما يحدث عندما تنشر نسخة جديدة من التطبيق.

تثبيت بيئة محلية: Minikube و Kind

قبل أن نبدأ بالمفاهيم، نحتاج Cluster محلي للتجربة. أشهر خيارين:

1. Minikube

Minikube أداة تقوم بإنشاء Cluster واحد-العقدة (Single-node) على جهازك. مناسب جدًا للتجربة والتعلم.

1. ثبّت Minikube من الموقع الرسمي حسب نظام التشغيل.
2. ثبّت أيضًا kubectl (الأداة الرئيسية للتعامل مع Kubernetes).
3. أنشئ Cluster:

   minikube start

4. تحقق من عمل Cluster:

   kubectl get nodes

2. Kind (Kubernetes in Docker)

Kind يعمل عبر Docker؛ ينشئ Kubernetes Cluster داخل حاويات دوكر. إذا كان لديك Docker مثبت مسبقًا، غالبًا سيكون تثبيته بسيطًا.

1. ثبّت Kind (باستخدام go أو binary أو عبر package manager).
2. أنشئ Cluster:

   kind create cluster

3. ثم استخدم kubectl كما هو:

   kubectl cluster-info

في باقي المقال سنستخدم الأوامر بصيغة عامة تنطبق على Minikube وKind وأي Cluster آخر.

المفاهيم الأساسية في Kubernetes للمطورين

1. Pod: أصغر وحدة تشغيل

الـ Pod هو أصغر كيان يمكن لـ Kubernetes تشغيله. يحتوي على حاوية واحدة أو أكثر تعمل معًا وتشارك:

• نفس الـ IP الداخلي.
• نفس التخزين المؤقت (Volumes) إن وُجد.
• نفس دورة الحياة (تُخلق وتُنهى معًا).

في أغلب التطبيقات البسيطة، يكون Pod = حاوية واحدة تحتوي تطبيق الويب أو الخدمة.

2. Deployment: كيف تُشغّل نسخ متعددة من تطبيقك

الـ Deployment هو الطريقة الموصى بها لتشغيل Pods وإدارتها. هو تعريف يحدد:

• أي Image (صورة Docker) تُشغّل.
• كم عدد النسخ (replicas) من التطبيق.
• سياسة التحديث (Rolling Update).

عندما تنشئ Deployment، يقوم Kubernetes بإنشاء ReplicaSet يتولى المحافظة على عدد الـ Pods وفق المطلوب. إذا تعطل Pod، يتم إنشاء Pod جديد تلقائيًا.

3. Service: الوصول إلى التطبيق داخل Cluster وخارجه

الـ Service يوفر عنوانًا ثابتًا (Stable IP / DNS) للوصول إلى Pods المتغيرة. لأن Pods تُنشأ وتُحذف وتتغير عناوينها، تحتاج طبقة ثابتة أمامها.

هناك أنواع مختلفة من Services، أبرزها:

• ClusterIP: الوصول فقط من داخل Cluster (الافتراضي).
• NodePort: فتح منفذ على كل Node يسمح بالوصول من خارج Cluster.
• LoadBalancer: استخدام Load Balancer خارجي (غالبًا على Cloud).

لمحة سريعة عن ملفات YAML في Kubernetes

تعريفات Kubernetes غالبًا تُكتب في ملفات بصيغة YAML. الفكرة بسيطة:

• كل ملف يصف كائن (أو أكثر) من نوع معين: Deployment، Service، ConfigMap، إلخ.
• كل كائن يحدد:
  • apiVersion: نسخة الـ API المستخدمة.
  • kind: نوع الكائن (Deployment, Service).
  • metadata: اسم وعلامات (labels).
  • spec: المواصفات (ما الذي نريده بالضبط).

كمطور، ستتعامل بشكل شبه دائم مع هذه الملفات. تعديل صغير في الـ YAML قد يعني إصدار جديد من تطبيقك، وهذا يشبه مفهوم GitOps الذي شرحناه في مقال GitOps باختصار: كيف تجعل Git مدير البنية التحتية.

إعداد تطبيق ويب بسيط داخل Kubernetes

لنفرض أن لدينا تطبيق ويب بسيط جدًا يعمل عبر حاوية Docker منشورة على Docker Hub، مثل:

docker.io/library/nginx:latest

سنعتبره تطبيقنا الأول على Kubernetes، وننشئ له Deployment وService.

1. ملف Deployment بسيط

أنشئ ملف باسم deployment.yaml بالمحتوى التالي (يمكن تعديل الاسم والصورة لاحقًا):

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-first-app
  labels:
    app: my-first-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: my-first-app
  template:
    metadata:
      labels:
        app: my-first-app
    spec:
      containers:
      - name: my-first-app
        image: nginx:latest
        ports:
        - containerPort: 80

شرح سريع لأهم الأسطر من منظور Kubernetes للمطورين:

• replicas: 2 يعني نريد نسختين (Pods) من التطبيق.
• selector.matchLabels يحدد أي Pods تتبع هذا الـ Deployment عبر label app: my-first-app.
• داخل template.spec.containers حددنا:
  • اسم الحاوية.
  • الصورة docker image (هنا nginx).
  • المنفذ الذي يستمع عليه التطبيق داخل الحاوية 80.

تطبيق ملف الـ Deployment على Cluster

من داخل نفس المجلد:

kubectl apply -f deployment.yaml

تحقق من الـ Pods:

kubectl get pods

يجب أن ترى اثنين من الـ Pods بالأسماء التي تبدأ بـ my-first-app-... وحالة Running.

2. إنشاء Service للوصول إلى التطبيق

الآن التطبيق يعمل داخل Cluster، لكن لا يوجد طريقة للوصول إليه من المتصفح (من خارج Cluster) إلا إذا أنشأنا Service.

أنشئ ملف جديد باسم service.yaml:

apiVersion: v1
kind: Service
metadata:
  name: my-first-app-service
spec:
  selector:
    app: my-first-app
  type: NodePort
  ports:
  - port: 80
    targetPort: 80
    nodePort: 30080

ماذا يعني ذلك؟

• selector.app: my-first-app يعني أن هذا الـ Service يوجّه الترافيك إلى كل Pod تحمل هذا الـ label.
• type: NodePort يفتح منفذ ثابت على كل Node في Cluster.
• port: 80 هو المنفذ الداخلي للـ Service داخل Cluster.
• targetPort: 80 هو المنفذ داخل الحاوية (تطبيق nginx).
• nodePort: 30080 هو المنفذ على الجهاز المضيف الذي ستفتح منه المتصفح.

طبّق Service:

kubectl apply -f service.yaml

ثم تحقق:

kubectl get services

ستجد my-first-app-service مع المنافذ المحددة. الآن يمكنك فتح المتصفح على:

• مع Minikube:
  • احصل على IP:

    minikube ip

  • افتح: http://<minikube-ip>:30080
• مع Kind: غالبًا تحتاج لعمل port-forward أو إعدادات خاصة، مثل:

  kubectl port-forward svc/my-first-app-service 8080:80

  ثم زيارة http://localhost:8080.

العمل اليومي مع Kubernetes للمطورين: أوامر أساسية

بعد أن قمت بتشغيل أول تطبيق، ستحتاج لمجموعة أوامر أساسية للتعامل اليومي:

• مشاهدة الموارد:

  kubectl get pods
  kubectl get deployments
  kubectl get services

• معلومات تفصيلية:

  kubectl describe pod <pod-name>
  kubectl describe deployment my-first-app

• سجلات التطبيق (Logs):

  kubectl logs <pod-name>

• حذف موارد:

  kubectl delete -f deployment.yaml
  kubectl delete -f service.yaml

تحديث التطبيق: من منظور المطور

لنفرض أن لديك نسخة جديدة من التطبيق منشورة كصورة Docker جديدة مثل:

myuser/my-first-app:v2

لتحديث التطبيق في Kubernetes:

1. عدّل ملف deployment.yaml:

   containers:
   - name: my-first-app
     image: myuser/my-first-app:v2

2. أعد تطبيق الملف:

   kubectl apply -f deployment.yaml

3. راقب عملية التحديث:

   kubectl rollout status deployment/my-first-app

Kubernetes سيقوم بعمل Rolling Update: تشغيل النسخ الجديدة تدريجيًا وإيقاف القديمة مع الحفاظ على التوافر (Availability) قدر الإمكان.

تنظيم المشروع: فصل الكود عن البنية التحتية

من أفضل الممارسات في استخدام Kubernetes للمطورين:

• حفظ ملفات YAML داخل مجلد خاص في مشروعك مثل k8s/.
• التعامل معها كجزء من الكود؛ تُراجع بكود ريفيو وتُخزّن في Git.
• إعداد بيئات متعددة:
  • k8s/dev للبيئة التطويرية.
  • k8s/stage للبيئة التجريبية.
  • k8s/prod للبيئة الإنتاجية.

هذا الأسلوب يمهّد لتبنّي أسلوب GitOps الذي يربط بين كود التطبيق وبنية التشغيل كما شرحنا بتفصيل أكثر في مقال GitOps باختصار: كيف تجعل Git مدير البنية التحتية.

نصائح عملية للمطورين المبتدئين مع Kubernetes

• ابدأ بحاوية واحدة بسيطة: استخدم nginx أو تطبيق API بسيط بدلًا من مشروع معقد، حتى تركز على فهم Kubernetes نفسه أولًا.
• افصل بين مشاكل التطبيق ومشاكل Kubernetes: إذا لم يعمل التطبيق، تأكد أولًا أنه يعمل في Docker عادي قبل نقله إلى Kubernetes.
• استخدم namespaces للتجارب:

  kubectl create namespace lab
  kubectl config set-context --current --namespace=lab

  ثم نفّذ كل التجارب داخل هذا الـ namespace.
• تعرف على ConfigMaps وSecrets لاحقًا: لإدارة المتغيرات الحساسة وإعدادات البيئة بدلًا من وضعها في الكود أو الـ Image.
• تعلم قراءة الأحداث (Events):

  kubectl get events --sort-by=.metadata.creationTimestamp

  يساعدك كثيرًا في تشخيص مشاكل النشر.

خلاصة: أين تضع Kubernetes في صندوق أدواتك كمطور؟

Kubernetes للمطورين لم يعد رفاهية في كثير من الفرق، بل أصبح جزءًا من بيئة العمل الطبيعية، خصوصًا مع انتشار المعمارية المعتمدة على الخدمات المصغّرة (Microservices) والحاويات. ما تحتاجه كبداية:

1. Cluster محلي عبر Minikube أو Kind.
2. فهم المفاهيم الأساسية: Pods, Deployments, Services.
3. القدرة على كتابة وتعديل ملفات YAML بسيطة.
4. استخدام أوامر kubectl الأساسية للنشر والمتابعة والتشخيص.

بعد إتقان هذه الأساسيات، يمكنك التوسع نحو موضوعات أكثر تقدمًا مثل Ingress، Autoscaling، إدارة التخزين، والمراقبة (Monitoring)، وربط ذلك مع CI/CD وGitOps. الأهم هو أن تبدأ بتجربة عملية على جهازك، تنشر أول تطبيق، وتتعلم من الأخطاء خطوة بخطوة.