استيعاب حاويات Dev في VS Code

أنشئ بيئات تطوير متسقة وقابلة للنقل وقابلة للتكرار باستخدام حاويات التطوير

Page content

يواجه المطورون غالبًا مشكلة “يعمل على جهازي” بسبب اختلافات في الاعتماديات، إصدارات الأدوات، أو اختلافات أنظمة التشغيل. الحاويات التطويرية في Visual Studio Code (VS Code) تحل هذه المشكلة بشكل أنيق — من خلال السماح لك بالتطوير داخل بيئة مُحاوية تم تكوينها خصيصًا لمشروعك.

تتطلب تطوير البرمجيات الحديثة بيئات متسقة وقابلة للتكرار تعمل عبر الأجهزة وأنظمة التشغيل. سواء كنت تعمل على مشروع تحليل بيانات باستخدام Python، تطبيق ويب باستخدام Node.js، أو خدمة ميكرو باستخدام Go، فإن ضمان أن كل عضو في الفريق لديه نفس إعداد التطوير يمكن أن يكون تحديًا.

vs code dev containers

يمر هذا الدليل الشامل بشرح ما هي الحاويات التطويرية، ولماذا هي مفيدة، وكيفية إعدادها في VS Code لتدفق عمل تطوير قابل للنقل. ستتعلم كل شيء من الإعداد الأساسي إلى التكوينات المتقدمة باستخدام Docker Compose والأساليب المثلى للتعاون بين الفريق.


🧩 ما هي الحاويات التطويرية؟

الحاويات التطويرية هي ميزة تقدمها إضافة VS Code Remote - Containers (الآن جزء من VS Code Remote Development). وهي تسمح لك بفتح مشروعك في حاوية Docker تم تكوينها مسبقًا مع جميع الاعتماديات واللغات والأدوات.

فكر فيها على أنها:

“بيئة تطوير كاملة، مُعرفة ككود.”

بدلاً من تثبيت Python وNode.js وقواعد البيانات وأدوات متعددة مباشرة على جهازك، تعرّفها في ملفات تكوين. عندما تفتح المشروع في VS Code، فإنه ينشئ تلقائيًا حاوية تحتوي على كل شيء مثبت ومُكوّن تمامًا كما تم تحديده.

يحتوي إعداد الحاوية التطويرية عادةً على:

  • ملف Dockerfile أو مرجع إلى صورة قاعدة (يحدد نظام التشغيل، اللغات والأدوات الخاصة بالحاوية)
  • ملف devcontainer.json (يحدد إعدادات مساحة العمل، إضافات VS Code، توجيه المنافذ، المتغيرات البيئية، وال명령ات الافتراضية)
  • ملف docker-compose.yml (اختياري) إذا كان مشروعك يعتمد على خدمات متعددة (مثل قواعد البيانات، Redis، قوائم الرسائل، إلخ)

⚙️ لماذا استخدام الحاويات التطويرية؟

هنا ما يجعلها قوية:

  • قابلية التكرار: يستخدم كل مطور ونظام CI نفس البيئة بالضبط. لا توجد مشكلة “يعمل على جهازي لكن لا يعمل على جهازك”. ما يعمل على جهازك سيقوم بنفسه على جهاز زميلك سواء كان يعمل على ويندوز أو ماك أو لينكس.

  • العزلة: لا حاجة لتلوث جهازك المحلي باعتماديات متعارضة. يمكنك العمل على مشاريع متعددة تتطلب إصدارات مختلفة من Python وNode.js وأدوات أخرى دون وجود تعارضات في الإصدارات أو تبديل بيئات افتراضية.

  • النقل: تعمل على أي نظام تشغيل يدعم Docker. تنتقل بيئتك التطويرية مع كودك. انسخ مستودعًا، فتحه في VS Code، وستكون جاهزًا للتطوير في دقائق — بغض النظر عن نظام التشغيل الذي تستخدمه.

  • التوافق بين الفريق: تكوين واحد مشاركة عبر فريقك بأكمله. يمكن للموظفين الجدد أن يبدأوا العمل في دقائق بدلًا من قضاء ساعات (أو أيام) في إعداد بيئة التطوير مع الأدوات والإصدارات الصحيحة.

  • التوحيد: تثبيت إضافات VS Code، الاعتماديات اللغوية والأدوات تلقائيًا عند فتح المشروع. يمكن لل명령ات بعد الإنشاء أن تقوم بتشغيل عمليات هجرة قاعدة البيانات، إدخال البيانات، أو أداء مهام إعداد أخرى دون تدخل يدوي.

  • الأمان: عزل الاعتماديات المحتملة الخطرة في الحاويات. إذا كنت بحاجة لاختبار إصدار أقدم أو معرض للاختراق من مكتبة، فإنه يبقى مُحاطًا ولا يؤثر على نظامك المضيف.

مثال عملي: تخيل أنك انضممت لفريق يعمل على مشروع ميكرو خدمات يستخدم Python 3.11، PostgreSQL 15، Redis، وElasticsearch. دون استخدام الحاويات التطويرية، ستنفق ساعات في تثبيت وإعداد كل عنصر. مع استخدام الحاويات التطويرية، تفتح المشروع في VS Code، ودعه يبني الحاوية، وستبدأ في كتابة الكود خلال 5 إلى 10 دقائق.


🧱 إعداد حاوية تطويرية في VS Code

لنذهب خطوة بخطوة.

1. تثبيت الأدوات المطلوبة

قبل البدء، تأكد من أن لديك ما يلي مثبتًا:

  • Docker Desktop (أو بيئة حاويات مكافئة مثل Podman)

    • لـ Windows/Mac: قم بتنزيل وتثبيت Docker Desktop
    • لـ Linux: تثبيت Docker Engine وتأكد من أن مستخدمك في مجموعة docker
  • VS Code (يُنصح بإصدار أحدث)

  • إضافة الحاويات التطويرية (من قبل مايكروسوفت)

    • افتح VS Code
    • اذهب إلى الإضافات (Ctrl+Shift+X أو Cmd+Shift+X على ماك)
    • ابحث عن “الحاويات التطويرية”
    • قم بتثبيت الإضافة ذات المعرف: ms-vscode-remote.remote-containers

تحقق من إعدادك:

# تحقق من تشغيل Docker
docker --version
docker ps

# يجب أن يعرض إصدار Docker والحاويات التي تعمل (إن وجدت)

2. تهيئة الحاوية التطويرية

افتح مجلد مشروعك في VS Code وافتح لوحة الأوامر (Ctrl+Shift+P أو Cmd+Shift+P على ماك)، ثم اكتب واختر:

الحاويات التطويرية: إضافة ملفات تكوين الحاوية التطويرية...

سيعرض VS Code قائمة من القوالب المُعدة مسبقًا للبيئات. اختر واحدة تتطابق مع مشروعك:

  • Node.js — مشاريع JavaScript/TypeScript
  • Python — تحليل البيانات، تطبيقات الويب، النصوص
  • Go — تطبيقات وخدمات Go
  • .NET — تطبيقات C#/F#
  • Java — مشاريع Spring Boot، Maven، Gradle
  • Docker-in-Docker — عندما تحتاج إلى Docker داخل الحاوية
  • وغيرها الكثير…

يمكنك أيضًا اختيار ميزات إضافية مثل:

  • أدوات شائعة (git، curl، wget)
  • عميل قواعد البيانات
  • أدوات سحابة (AWS، Azure، GCP)

يقوم هذا المُرشد بإنشاء مجلد .devcontainer يحتوي على:

  • devcontainer.json — الملف الرئيسي للتكوين
  • Dockerfile — تعريف الصورة المخصصة (أو مرجع إلى صورة مُبنية مسبقًا)

3. تخصيص ملف devcontainer.json

ملف devcontainer.json هو حيث يحدث السحر. إليك مثالًا موثقًا جيدًا لمشروع Node.js:

{
  // اسم الحاوية الذي يظهر في شريط الحالة في VS Code
  "name": "حاوية تطوير Node.js",
  
  // إعدادات البناء - يمكن استخدام Dockerfile أو صورة مُبنية مسبقًا
  "build": {
    "dockerfile": "Dockerfile",
    "context": ".."
  },
  
  // خيار بديل: استخدام صورة مُبنية مسبقًا بدلًا من Dockerfile
  // "image": "mcr.microsoft.com/devcontainers/javascript-node:18",
  
  // إعدادات مساحة العمل
  "customizations": {
    "vscode": {
      // إعدادات VS Code التي تُطبّق داخل الحاوية
      "settings": {
        "terminal.integrated.defaultProfile.linux": "bash",
        "editor.formatOnSave": true,
        "editor.defaultFormatter": "esbenp.prettier-vscode"
      },
      
      // الإضافات التي سيتم تثبيتها تلقائيًا
      "extensions": [
        "dbaeumer.vscode-eslint",
        "esbenp.prettier-vscode",
        "eamodio.gitlens",
        "ms-azuretools.vscode-docker"
      ]
    }
  },
  
  // توجيه المنافذ - جعل منافذ الحاوية متاحة على المضيف
  "forwardPorts": [3000, 5432],
  "portsAttributes": {
    "3000": {
      "label": "التطبيق",
      "onAutoForward": "notify"
    }
  },
  
  // الأوامر التي تُنفذ في مراحل مختلفة
  "postCreateCommand": "npm install",     // بعد إنشاء الحاوية
  "postStartCommand": "npm run dev",      // بعد بدء تشغيل الحاوية
  
  // المتغيرات البيئية
  "containerEnv": {
    "NODE_ENV": "development",
    "PORT": "3000"
  },
  
  // تشغيل الحاوية كمستخدم غير جذر (مُوصى به للأمان)
  "remoteUser": "node",
  
  // تثبيت مجلدات إضافية
  "mounts": [
    "source=${localEnv:HOME}/.ssh,target=/home/node/.ssh,readonly,type=bind"
  ]
}

شرح خيارات التكوين الرئيسية:

  • name — الاسم الذي يُعرض في شريط الحالة في VS Code
  • build / image — استخدام Dockerfile أو صورة مُبنية مسبقًا
  • customizations.vscode.extensions — إضافات VS Code التي سيتم تثبيتها تلقائيًا
  • forwardPorts — المنافذ التي سيتم إظهارها من الحاوية إلى المضيف
  • postCreateCommand — تُنفذ مرة واحدة عند إنشاء الحاوية لأول مرة (مثل تثبيت الاعتماديات)
  • postStartCommand — تُنفذ كل مرة تبدأ فيها الحاوية
  • containerEnv — المتغيرات البيئية المتاحة داخل الحاوية
  • remoteUser — الحساب المستخدم داخل الحاوية
  • mounts — الملفات/المجلدات الإضافية التي سيتم تثبيتها (مثل مفاتيح SSH)

💡 نصائح مُفيدة:

  • استخدم postCreateCommand للعمليات البطيئة (npm install، pip install)
  • استخدم postStartCommand للمهام السريعة عند بدء التشغيل (هجرة قاعدة البيانات)
  • حدد دائمًا الإضافات التي يحتاجها مشروعك — هذا يضمن توافق الأدوات
  • استخدم المتغيرات البيئية للإعدادات التي تختلف بين المطورين

4. بناء وفتح في الحاوية

بمجرد أن تكون إعداداتك جاهزة، حان الوقت لتشغيل بيئة التطوير الخاصة بك:

افتح لوحة الأوامر (Ctrl+Shift+P / Cmd+Shift+P) وقم بتشغيل:

الحاويات التطويرية: إعادة فتح في الحاوية

ما يحدث بعد ذلك:

  1. بناء الصورة — يقوم VS Code ببناء صورة Docker بناءً على Dockerfile أو يسحب صورة مُبنية مسبقًا. قد يستغرق هذا بضع دقائق في المرة الأولى.

  2. إنشاء الحاوية — يقوم Docker بإنشاء حاوية جديدة من الصورة المبنية.

  3. تثبيت المجلدات — يتم تثبيت مجلد مشروعك داخل الحاوية، مما يجعل كودك متاحًا داخلها.

  4. تثبيت الإضافات — يتم تثبيت جميع الإضافات المُحددة في devcontainer.json تلقائيًا داخل الحاوية.

  5. العمليات بعد الإنشاء — يتم تنفيذ postCreateCommand الخاص بك (مثل npm install، pip install -r requirements.txt).

  6. جاهز! — يعيد VS Code الاتصال بالحاوية، و你现在 تطور داخلها.

تحقق من أنك داخل الحاوية:

يمكنك التأكد من أنك تعمل داخل الحاوية عن طريق فتح نافذة ترميل وتشغيل:

# تحقق من نظام التشغيل
uname -a
# الناتج: Linux ... (نواة الحاوية)

# تحقق من اسم المضيف (عادةً هو معرف الحاوية)
hostname
# الناتج: abc123def456

# تحقق من العمليات الجارية
ps aux
# سترى عمليات الحاوية، وليس عمليات نظامك المضيف

لاحظ أن شريط الحالة في VS Code (الزاوية السفلى اليسرى) الآن يعرض: الحاوية التطويرية: [اسم حاويةك]

أوامر دورة حياة الحاوية:

  • إعادة بناء الحاويةالحاويات التطويرية: إعادة بناء الحاوية (عندما تغير Dockerfile)
  • إعادة بناء بدون ذاكرة التخزين المؤقتالحاويات التطويرية: إعادة بناء الحاوية بدون ذاكرة التخزين المؤقت (لبناء نظيف)
  • إعادة فتح محليًاالحاويات التطويرية: إعادة فتح المجلد محليًا (الخروج من الحاوية، العمل على المضيف)

5. إضافة خدمات إضافية (اختياري)

تتطلب التطبيقات الواقعية غالبًا قواعد بيانات، طبقات تخزين مؤقت، قوائم الرسائل، أو خدمات أخرى. يمكنك استخدام Docker Compose لتنظيم عدة حاويات.

مثال: تطبيق كامل مع Node.js، PostgreSQL، وRedis

أنشئ ملف docker-compose.yml في مجلد .devcontainer:

version: "3.8"

services:
  # الحاوية التطويرية الرئيسية
  app:
    build: 
      context: ..
      dockerfile: .devcontainer/Dockerfile
    
    volumes:
      # تثبيت مجلد المشروع
      - ..:/workspace:cached
      # استخدام حجم مسمى لـ node_modules (أداء أفضل)
      - node_modules:/workspace/node_modules
    
    # الحفاظ على تشغيل الحاوية
    command: sleep infinity
    
    # الوصول إلى خدمات أخرى
    depends_on:
      - db
      - redis
    
    environment:
      DATABASE_URL: postgresql://dev:secret@db:5432/appdb
      REDIS_URL: redis://redis:6379

  # قاعدة بيانات PostgreSQL
  db:
    image: postgres:15-alpine
    restart: unless-stopped
    volumes:
      - postgres-data:/var/lib/postgresql/data
    environment:
      POSTGRES_USER: dev
      POSTGRES_PASSWORD: secret
      POSTGRES_DB: appdb
    ports:
      - "5432:5432"

  # Redis كاش
  redis:
    image: redis:7-alpine
    restart: unless-stopped
    volumes:
      - redis-data:/data
    ports:
      - "6379:6379"

volumes:
  postgres-data:
  redis-data:
  node_modules:

ثم، قم بتحديث ملف devcontainer.json لاستخدام Docker Compose:

{
  "name": "بيئة التطوير الكاملة",
  
  // استخدام docker-compose بدلًا من حاوية واحدة
  "dockerComposeFile": "docker-compose.yml",
  
  // أي خدمة يجب استخدامها كحاوية تطويرية
  "service": "app",
  
  // مسار مجلد العمل داخل الحاوية
  "workspaceFolder": "/workspace",
  
  "customizations": {
    "vscode": {
      "extensions": [
        "dbaeumer.vscode-eslint",
        "esbenp.prettier-vscode",
        "ms-azuretools.vscode-docker",
        "ckolkman.vscode-postgres"  // عميل PostgreSQL
      ]
    }
  },
  
  "forwardPorts": [3000, 5432, 6379],
  
  "postCreateCommand": "npm install && npm run db:migrate",
  
  "remoteUser": "node"
}

ما يوفره هذا الإعداد:

  • app — حاوية التطوير مع Node.js
  • db — قاعدة بيانات PostgreSQL، قابلة للوصول إليها من تطبيقك على db:5432
  • redis — كاش Redis، قابلة للوصول إليها من تطبيقك على redis:6379
  • الحجوم المسمية — تُحافظ على بيانات قاعدة البيانات بين إعادة تشغيل الحاوية
  • توجيه المنافذ — الوصول إلى جميع الخدمات من جهازك المضيف

الاتصال بالخدمات من كودك:

// في تطبيق Node.js الخاص بك
const { Pool } = require('pg');
const redis = require('redis');

// اتصال بقاعدة البيانات
const pool = new Pool({
  connectionString: process.env.DATABASE_URL
  // يحل إلى: postgresql://dev:secret@db:5432/appdb
});

// اتصال بـ Redis
const redisClient = redis.createClient({
  url: process.env.REDIS_URL
  // يحل إلى: redis://redis:6379
});

الوصول إلى الخدمات من جهازك المضيف:

  • التطبيق: http://localhost:3000
  • PostgreSQL: localhost:5432 (باستخدام أي عميل PostgreSQL)
  • Redis: localhost:6379 (باستخدام redis-cli أو أدوات واجهة الرسوم)

الآن، عندما تفتح المشروع في VS Code، تبدأ جميع الخدمات تلقائيًا!


🧠 نصائح متقدمة وأفضل الممارسات

استخدام صور مُبنية مسبقًا

وفر وقت بناء كبير من خلال البدء من صور devcontainer الرسمية من مايكروسوفت:

{
  "image": "mcr.microsoft.com/devcontainers/python:3.11",
  "features": {
    "ghcr.io/devcontainers/features/git:1": {},
    "ghcr.io/devcontainers/features/github-cli:1": {}
  }
}

الميزات هي نصوص تثبيت قابلة لإعادة الاستخدام ل أدوات شائعة (Git، GitHub CLI، Node، AWS CLI، إلخ).

أفضل الممارسات في التحكم في الإصدار

احفظ دائمًا مجلد .devcontainer:

git add .devcontainer/
git commit -m "إضافة تكوين الحاوية التطويرية"
git push

هذا يضمن:

  • ✅ يتم تلقائيًا إعطاء المطورين الجدد البيئة
  • ✅ تتبع تغييرات البيئة وقابلة للمراجعة
  • ✅ الجميع يعمل في نفس الإعداد

نصيحة مُفيدة: أضف قسم README يشرح إعداد الحاوية التطويرية:


## إعداد التطوير

يستخدم هذا المشروع VS Code Dev Containers. للبدء:

1. تثبيت Docker Desktop و VS Code
2. تثبيت إضافة "الحاويات التطويرية"
3. استنسخ هذا المستودع
4. افتحه في VS Code
5. انقر على "إعادة فتح في الحاوية" عند الطلب

التصحيح داخل الحاويات

يعمل التصحيح بسلاسة. اضبط ملف launch.json كما عادة:

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "تشغيل Node.js",
      "type": "node",
      "request": "launch",
      "program": "${workspaceFolder}/index.js",
      "skipFiles": ["<node_internals>/**"]
    }
  ]
}

ضع نقاط توقف وتصحيح بشكل طبيعي — VS Code يتعامل مع الاتصال بالحاوية تلقائيًا.

توافق CI/CD

استخدم نفس صورة الحاوية في أنبوب CI/CD الخاص بك:

# مثال GitHub Actions
name: CI
on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    container:
      image: mcr.microsoft.com/devcontainers/javascript-node:18
    steps:
      - uses: actions/checkout@v3
      - run: npm install
      - run: npm test

هذا يضمن توافق التطوير/الإنتاج — إذا نجحت الاختبارات محليًا، فسوف تنجح في CI.

تحسين الأداء

للمستخدمين في ماك أو ويندوز — استخدم الحجوم المسمية للاعتماديات:

{
  "mounts": [
    "source=myproject-node_modules,target=${containerWorkspaceFolder}/node_modules,type=volume"
  ]
}

هذا يحسن بشكل كبير أداء مدخلات/مخرجات الملفات لـ node_modules، venv، إلخ.

التطوير متعدد المراحل

أنشئ تكوينات مختلفة لمهام الفريق المختلفة:

.devcontainer/
├── devcontainer.json          # الافتراضي (الكامل)
├── frontend/
│   └── devcontainer.json      # فقط للواجهة الأمامية (أخف)
└── backend/
    └── devcontainer.json      # فقط للخلفية (مع قاعدة البيانات)

يمكن للمطورين اختيار بيئتهم عند فتح المشروع.

العمل مع مفاتيح SSH وGit

تثبيت مفاتيح SSH الخاصة بك للقيام بعمليات Git:

{
  "mounts": [
    "source=${localEnv:HOME}${localEnv:USERPROFILE}/.ssh,target=/home/node/.ssh,readonly,type=bind"
  ],
  "postCreateCommand": "ssh-add ~/.ssh/id_ed25519 || true"
}

ملفات البيئة المخصصة

تحميل تكوينات مخصصة للبيئة:

{
  "runArgs": ["--env-file", ".devcontainer/.env"]
}

.devcontainer/.env:

API_KEY=dev_key_here
DEBUG=true
LOG_LEVEL=debug

🔧 حل مشكلات شائعة

الحاوية لا تبدأ

الخطأ: لا يمكن الاتصال بـ Docker daemon

الحل:

  • تأكد من أن Docker Desktop يعمل
  • على Linux، تحقق من: sudo systemctl status docker
  • تحقق من أن Docker في مسارك: docker --version

الأداء البطيء على ماك أو ويندوز

المشكلة: العمليات الملفية بطيئة

الحلول:

  1. استخدم الحجوم المسمية لـ node_modules، venv، إلخ

  2. تفعيل مشاركة الملفات في إعدادات Docker Desktop

  3. فكر في استخدام خيارات تثبيت cached أو delegated:

    "workspaceMount": "source=${localWorkspaceFolder},target=/workspace,type=bind,consistency=cached"
    

الإضافات لا تُثبيت

المشكلة: الإضافات المحددة في devcontainer.json لا تُثبيت

الحلول:

  1. إعادة بناء الحاوية: الحاويات التطويرية: إعادة بناء الحاوية
  2. تحقق من أن معرفات الإضافات صحيحة
  3. تأكد من أن الإضافات تدعم الحاويات البعيدة (معظمها تدعم)

المنفذ مُستخدم بالفعل

الخطأ: المنفذ 3000 مُستخدم بالفعل

الحلول:

  1. توقف الحاويات المتعارضة: docker ps و docker stop <container>
  2. تغيير خريطة المنفذ في forwardPorts
  3. استخدم منافذ ديناميكية: VS Code سيقوم تلقائيًا بتخصيص المنافذ المتاحة

التغييرات في Dockerfile غير مطبقة

المشكلة: تغيير Dockerfile لكن التغييرات لا تظهر

الحل: إعادة بناء بدون ذاكرة التخزين المؤقت:

الحاويات التطويرية: إعادة بناء الحاوية بدون ذاكرة التخزين المؤقت

الحاوية تغلق فورًا

المشكلة: تبدأ الحاوية ثم تتوقف

الحل: أضف أمرًا للحفاظ على تشغيلها في docker-compose.yml:

command: sleep infinity

أو في devcontainer.json:

{
  "overrideCommand": true
}

✅ الخاتمة

الحاويات التطويرية في VS Code تجلب التوافق، البساطة، والتوحيد لتدفق عمل التطوير الخاص بك. تحوّل إعدادات معقدة وعديمة المرونة إلى بيئات مُعرفة ككود تعمل بشكل مثالي، بغض النظر عن جهازك أو نظام التشغيل.

الخلاصة الرئيسية:

  • 🎯 القضاء على مشكلة “يعمل على جهازي” — يستخدم الجميع بيئات متطابقة
  • 🚀 التوحيد السريع — يمكن للمطورين الجدد أن يكونوا فعالين في دقائق، وليس أيامًا
  • 🔒 الأمان الأفضل — عزل الاعتماديات عن نظامك المضيف
  • 📦 النقل — تنتقل بيئتك مع كودك
  • 🤝 توافق الفريق — لا توجد تعارضات في إصدارات الاعتماديات
  • 🔄 توافق CI/CD — استخدم نفس الصورة في التطوير والتكامل المستمر

سواء كنت تعمل على نسخة بسيطة من Python أو بنية معقدة من ميكرو خدمات مع قواعد بيانات متعددة، فإن الحاويات التطويرية توفر أساسًا قويًا لتطوير البرمجيات الحديثة.

إذا كنت تعمل على مشاريع متعددة اللغات، تساهم في مستودعات مفتوحة المصدر، توظف مطورين جدد بشكل متكرر، أو ببساطة ترغب في بيئات تطوير نظيفة وقابلة للتكرار — الحاويات التطويرية هي أداة لا غنى عنها في مجموعتك.

ابدأ بخطوة صغيرة: جرّب الحاويات التطويرية في مشروعك التالي. بمجرد أن تجرب الفوائد، ستتساءل كيف كنت تطور دونها.

📚 مصادر مفيدة ومقالات مرتبطة

التوثيق الرسمي:

مقالات مرتبطة على هذا الموقع: