دمج TypeScript مع Docker: سلامة الأنواع في الحاويات لتطبيقات قوية

في تطوير البرمجيات الحديث، أصبحت الحاويات باستخدام Docker ممارسة قياسية. بالاقتران مع سلامة الأنواع التي توفرها TypeScript، يمكن للمطورين إنشاء تطبيقات أكثر موثوقية وقابلية للصيانة. يستكشف هذا الدليل الشامل كيفية دمج TypeScript مع Docker بشكل فعال، مما يضمن سلامة الأنواع في الحاويات طوال دورة حياة التطوير.

لماذا TypeScript و Docker؟

TypeScript تجلب الكتابة الثابتة إلى JavaScript، مما يمكن المطورين من اكتشاف الأخطاء في وقت مبكر من عملية التطوير. هذا يقلل من أخطاء وقت التشغيل ويحسن جودة التعليمات البرمجية. Docker يوفر بيئة متسقة ومعزولة للتطبيقات، مما يضمن تشغيلها بشكل موثوق عبر بيئات مختلفة، من التطوير إلى الإنتاج.

يوفر دمج هاتين التقنيتين العديد من الفوائد الرئيسية:

• تعزيز سلامة الأنواع: اكتشاف الأخطاء المتعلقة بالنوع أثناء وقت البناء، بدلاً من وقت التشغيل داخل الحاوية.
• تحسين جودة التعليمات البرمجية: تشجع الكتابة الثابتة لـ TypeScript على بنية تعليمات برمجية أفضل وقابلية للصيانة.
• بيئات متسقة: يضمن Docker تشغيل تطبيقك في بيئة متسقة، بغض النظر عن البنية التحتية الأساسية.
• تبسيط النشر: يبسط Docker عملية النشر، مما يسهل نشر التطبيقات في بيئات مختلفة.
• زيادة الإنتاجية: يساهم اكتشاف الأخطاء المبكر والبيئات المتسقة في زيادة إنتاجية المطورين.

إعداد مشروع TypeScript الخاص بك باستخدام Docker

للبدء، ستحتاج إلى مشروع TypeScript وتثبيت Docker على جهازك. إليك دليل خطوة بخطوة:

1. تهيئة المشروع

أنشئ دليلًا جديدًا لمشروعك وقم بتهيئة مشروع TypeScript:

            mkdir typescript-docker
cd typescript-docker
npm init -y
npm install typescript --save-dev
tsc --init
            

              
                Copy
              
            
          

سيؤدي هذا إلى إنشاء ملف `package.json` وملف `tsconfig.json`، الذي يكوّن مترجم TypeScript.

2. تكوين TypeScript

افتح `tsconfig.json` وقم بتكوين خيارات المترجم وفقًا لمتطلبات مشروعك. قد يبدو التكوين الأساسي كما يلي:

            {
  "compilerOptions": {
    "target": "es6",
    "module": "commonjs",
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  }
}
            

              
                Copy
              
            
          

إليك تفصيل للخيارات الرئيسية:

• `target`: يحدد إصدار ECMAScript المستهدف.
• `module`: يحدد إنشاء رمز الوحدة.
• `outDir`: يحدد دليل الإخراج لملفات JavaScript المترجمة.
• `rootDir`: يحدد الدليل الجذر لملفات المصدر.
• `strict`: يتيح جميع خيارات التحقق من النوع الصارمة.
• `esModuleInterop`: يتيح التشغيل البيني بين وحدات CommonJS و ES.

3. إنشاء ملفات المصدر

أنشئ دليل `src` وأضف ملفات مصدر TypeScript الخاصة بك. على سبيل المثال، أنشئ ملفًا باسم `src/index.ts` بالمحتوى التالي:

            // src/index.ts
function greet(name: string): string {
  return `Hello, ${name}!`;
}

console.log(greet("World"));
            

              
                Copy
              
            
          

4. إنشاء Dockerfile

أنشئ `Dockerfile` في جذر مشروعك. يحدد هذا الملف الخطوات المطلوبة لإنشاء صورة Docker الخاصة بك.

            # Use an official Node.js runtime as a parent image
FROM node:18-alpine

# Set the working directory in the container
WORKDIR /app

# Copy package.json and package-lock.json to the working directory
COPY package*.json ./

# Install dependencies
RUN npm install

# Copy TypeScript source files
COPY src ./src

# Compile TypeScript code
RUN npm run tsc

# Expose the port your app runs on
EXPOSE 3000

# Command to run the application
CMD ["node", "dist/index.js"]
            

              
                Copy
              
            
          

دعنا نحلل `Dockerfile`:

• `FROM node:18-alpine`: يستخدم صورة Node.js Alpine Linux الرسمية كصورة أساسية. Alpine Linux هي توزيعة خفيفة الوزن، مما يؤدي إلى أحجام صور أصغر.
• `WORKDIR /app`: يعين دليل العمل داخل الحاوية إلى `/app`.
• `COPY package*.json ./`: ينسخ ملفات `package.json` و `package-lock.json` إلى دليل العمل.
• `RUN npm install`: يثبت تبعيات المشروع باستخدام `npm`.
• `COPY src ./src`: ينسخ ملفات مصدر TypeScript إلى دليل العمل.
• `RUN npm run tsc`: يترجم رمز TypeScript باستخدام الأمر `tsc` (ستحتاج إلى تحديد هذا البرنامج النصي في `package.json` الخاص بك).
• `EXPOSE 3000`: يعرض المنفذ 3000 للسماح بالوصول الخارجي إلى التطبيق.
• `CMD ["node", "dist/index.js"]`: يحدد الأمر لتشغيل التطبيق عند بدء تشغيل الحاوية.

5. إضافة برنامج نصي للبناء

أضف برنامج `build` النصي إلى ملف `package.json` الخاص بك لترجمة رمز TypeScript:

            {
  "name": "typescript-docker",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "build": "tsc",
    "start": "node dist/index.js"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "devDependencies": {
    "typescript": "^4.0.0"
  },
  "dependencies": {}
}
            

              
                Copy
              
            
          

6. بناء صورة Docker

قم ببناء صورة Docker باستخدام الأمر التالي:

            docker build -t typescript-docker .
            

              
                Copy
              
            
          

يقوم هذا الأمر ببناء الصورة باستخدام `Dockerfile` في الدليل الحالي ويضع علامة عليها كـ `typescript-docker`. تحدد `.` سياق البناء، وهو الدليل الحالي.

7. تشغيل حاوية Docker

قم بتشغيل حاوية Docker باستخدام الأمر التالي:

            docker run -p 3000:3000 typescript-docker
            

              
                Copy
              
            
          

يقوم هذا الأمر بتشغيل صورة `typescript-docker` ويعين المنفذ 3000 على الجهاز المضيف إلى المنفذ 3000 في الحاوية. يجب أن ترى إخراج "Hello, World!" في جهازك الطرفي.

تكامل TypeScript و Docker المتقدم

الآن بعد أن أصبح لديك إعداد أساسي لـ TypeScript و Docker، دعنا نستكشف بعض التقنيات المتقدمة لتحسين سير عمل التطوير وضمان سلامة الأنواع في الحاويات.

1. استخدام Docker Compose

Docker Compose يبسط إدارة تطبيقات متعددة الحاويات. يمكنك تحديد خدمات تطبيقك وشبكاته ووحدات التخزين في ملف `docker-compose.yml`. إليك مثال:

            version: "3.8"
services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "3000:3000"
    volumes:
      - ./src:/app/src
    environment:
      NODE_ENV: development
            

              
                Copy
              
            
          

يحدد ملف `docker-compose.yml` هذا خدمة واحدة باسم `app`. يحدد سياق البناء و Dockerfile وتعيينات المنافذ ووحدات التخزين ومتغيرات البيئة.

لبدء تشغيل التطبيق باستخدام Docker Compose، قم بتشغيل الأمر التالي:

            docker-compose up -d
            

              
                Copy
              
            
          

تقوم العلامة `-d` بتشغيل التطبيق في وضع منفصل، مما يعني أنه سيتم تشغيله في الخلفية.

Docker Compose مفيد بشكل خاص عندما يتكون تطبيقك من خدمات متعددة، مثل الواجهة الأمامية والخلفية وقاعدة البيانات.

2. سير عمل التطوير مع إعادة التحميل السريع

للحصول على تجربة تطوير أفضل، يمكنك تكوين إعادة التحميل السريع، والذي يقوم تلقائيًا بتحديث التطبيق عند إجراء تغييرات على التعليمات البرمجية المصدر. يمكن تحقيق ذلك باستخدام أدوات مثل `nodemon` و `ts-node`.

أولاً، قم بتثبيت التبعيات المطلوبة:

            npm install nodemon ts-node --save-dev
            

              
                Copy
              
            
          

بعد ذلك، قم بتحديث ملف `package.json` الخاص بك باستخدام برنامج `dev` النصي:

            {
  "name": "typescript-docker",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "build": "tsc",
    "start": "node dist/index.js",
    "dev": "nodemon --watch 'src/**/*.ts' --exec ts-node src/index.ts"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "devDependencies": {
    "typescript": "^4.0.0",
    "nodemon": "^2.0.0",
    "ts-node": "^9.0.0"
  },
  "dependencies": {}
}
            

              
                Copy
              
            
          

قم بتعديل `docker-compose.yml` لربط دليل التعليمات البرمجية المصدر بالحاوية

            version: "3.8"
services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "3000:3000"
    volumes:
      - ./src:/app/src
      - ./node_modules:/app/node_modules
    environment:
      NODE_ENV: development
            

              
                Copy
              
            
          

قم بتحديث Dockerfile لاستبعاد خطوة الترجمة:

            # Use an official Node.js runtime as a parent image
FROM node:18-alpine

# Set the working directory in the container
WORKDIR /app

# Copy package.json and package-lock.json to the working directory
COPY package*.json ./

# Install dependencies
RUN npm install

# Copy TypeScript source files
COPY src ./src

# Expose the port your app runs on
EXPOSE 3000

# Command to run the application
CMD ["npm", "run", "dev"]
            

              
                Copy
              
            
          

الآن، قم بتشغيل التطبيق باستخدام Docker Compose:

            docker-compose up -d
            

              
                Copy
              
            
          

ستؤدي أي تغييرات تجريها على ملفات مصدر TypeScript تلقائيًا إلى إعادة تشغيل التطبيق داخل الحاوية، مما يوفر تجربة تطوير أسرع وأكثر كفاءة.

3. عمليات بناء متعددة المراحل

عمليات البناء متعددة المراحل هي تقنية قوية لتحسين أحجام صور Docker. تسمح لك باستخدام تعليمات `FROM` متعددة في `Dockerfile` واحد، ونسخ القطع الأثرية من مرحلة إلى أخرى.

إليك مثال على `Dockerfile` متعدد المراحل لتطبيق TypeScript:

            # Stage 1: Build the application
FROM node:18-alpine as builder

WORKDIR /app

COPY package*.json ./

RUN npm install

COPY src ./src

RUN npm run build

# Stage 2: Create the final image
FROM node:18-alpine

WORKDIR /app

COPY package*.json ./

RUN npm install --production

COPY --from=builder /app/dist ./dist

EXPOSE 3000

CMD ["node", "dist/index.js"]
            

              
                Copy
              
            
          

في هذا المثال، تقوم المرحلة الأولى (`builder`) بترجمة رمز TypeScript وإنشاء ملفات JavaScript. تقوم المرحلة الثانية بإنشاء الصورة النهائية، ونسخ الملفات الضرورية فقط من المرحلة الأولى. ينتج عن هذا حجم صورة أصغر، لأنه لا يتضمن تبعيات التطوير أو ملفات مصدر TypeScript.

4. استخدام متغيرات البيئة

متغيرات البيئة هي طريقة ملائمة لتكوين تطبيقك دون تعديل التعليمات البرمجية. يمكنك تحديد متغيرات البيئة في ملف `docker-compose.yml` أو تمريرها كمعلمات سطر أوامر عند تشغيل الحاوية.

للوصول إلى متغيرات البيئة في رمز TypeScript الخاص بك، استخدم الكائن `process.env`:

            // src/index.ts
const port = process.env.PORT || 3000;

console.log(`Server listening on port ${port}`);
            

              
                Copy
              
            
          

في ملف `docker-compose.yml` الخاص بك، حدد متغير البيئة:

            version: "3.8"
services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "3000:3000"
    environment:
      PORT: 3000
            

              
                Copy
              
            
          

5. تركيب وحدة التخزين لاستمرار البيانات

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

لتركيب وحدة تخزين، حدد الخيار `volumes` في ملف `docker-compose.yml` الخاص بك:

            version: "3.8"
services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "3000:3000"
    volumes:
      - ./data:/app/data
    environment:
      NODE_ENV: development
            

              
                Copy
              
            
          

سيؤدي هذا إلى تركيب الدليل `./data` على الجهاز المضيف إلى الدليل `/app/data` في الحاوية. سيتم الاحتفاظ بأي ملفات تم إنشاؤها في الدليل `/app/data` على الجهاز المضيف.

ضمان سلامة الأنواع في الحاويات

في حين أن Docker يوفر بيئة متسقة، فمن الأهمية بمكان التأكد من أن رمز TypeScript الخاص بك آمن للنوع داخل الحاوية. فيما يلي بعض أفضل الممارسات:

1. تكوين TypeScript صارم

قم بتمكين جميع خيارات التحقق من النوع الصارمة في ملف `tsconfig.json` الخاص بك. سيساعدك هذا في اكتشاف الأخطاء المحتملة المتعلقة بالنوع في وقت مبكر من عملية التطوير. تأكد من وجود "strict": true في tsconfig.json الخاص بك.

2. التدقيق وتنسيق التعليمات البرمجية

استخدم مدققًا ومُنسقًا للتعليمات البرمجية، مثل ESLint و Prettier، لفرض معايير الترميز واكتشاف الأخطاء المحتملة. قم بدمج هذه الأدوات في عملية البناء الخاصة بك للتحقق تلقائيًا من التعليمات البرمجية الخاصة بك بحثًا عن الأخطاء والتناقضات.

3. اختبار الوحدة

اكتب اختبارات وحدة للتحقق من وظائف التعليمات البرمجية الخاصة بك. يمكن أن تساعدك اختبارات الوحدة في اكتشاف الأخطاء المتعلقة بالنوع والتأكد من أن التعليمات البرمجية الخاصة بك تتصرف كما هو متوقع. هناك العديد من المكتبات لاختبار الوحدة في Typescript مثل Jest و Mocha.

4. التكامل المستمر والنشر المستمر (CI/CD)

قم بتنفيذ مسار CI/CD لأتمتة عملية البناء والاختبار والنشر. سيساعدك هذا في اكتشاف الأخطاء مبكرًا والتأكد من أن تطبيقك دائمًا في حالة قابلة للنشر. يمكن استخدام أدوات مثل Jenkins و GitLab CI و GitHub Actions لإنشاء مسارات CI/CD.

5. المراقبة والتسجيل

قم بتنفيذ المراقبة والتسجيل لتتبع أداء وسلوك تطبيقك في الإنتاج. سيساعدك هذا في تحديد المشكلات المحتملة والتأكد من أن تطبيقك يعمل بسلاسة. يمكن استخدام أدوات مثل Prometheus و Grafana للمراقبة، بينما يمكن استخدام أدوات مثل ELK Stack (Elasticsearch, Logstash, Kibana) للتسجيل.

أمثلة واقعية وحالات استخدام

فيما يلي بعض الأمثلة الواقعية لكيفية استخدام TypeScript و Docker معًا:

• بنية الخدمات المصغرة: TypeScript و Docker مناسبان تمامًا لبنى الخدمات المصغرة. يمكن تطوير كل خدمة مصغرة كمشروع TypeScript منفصل ونشرها كحاوية Docker.
• تطبيقات الويب: يمكن استخدام TypeScript لتطوير الواجهة الأمامية والخلفية لتطبيقات الويب. يمكن استخدام Docker لحاويات التطبيق ونشره في بيئات مختلفة.
• الوظائف غير الخادمية: يمكن استخدام TypeScript لكتابة وظائف غير خادمية، والتي يمكن نشرها كحاويات Docker إلى منصات غير خادمية مثل AWS Lambda أو Google Cloud Functions.
• خطوط أنابيب البيانات: يمكن استخدام TypeScript لتطوير خطوط أنابيب البيانات، والتي يمكن احتواؤها باستخدام Docker ونشرها إلى منصات معالجة البيانات مثل Apache Spark أو Apache Flink.

مثال: منصة تجارة إلكترونية عالمية

تخيل منصة تجارة إلكترونية عالمية تدعم لغات وعملات متعددة. تم تصميم الواجهة الخلفية باستخدام Node.js و TypeScript، مع خدمات مصغرة مختلفة تتعامل مع كتالوج المنتجات ومعالجة الطلبات وتكاملات بوابة الدفع. يتم احتواء كل خدمة مصغرة باستخدام Docker، مما يضمن نشرًا متسقًا عبر مناطق سحابية مختلفة (مثل AWS في أمريكا الشمالية و Azure في أوروبا و Google Cloud Platform في آسيا). تساعد سلامة النوع في TypeScript في منع الأخطاء المتعلقة بتحويلات العملات أو أوصاف المنتجات المترجمة، بينما يضمن Docker تشغيل كل خدمة مصغرة في بيئة متسقة، بغض النظر عن البنية التحتية الأساسية.

مثال: تطبيق لوجستي دولي

ضع في اعتبارك تطبيقًا لوجستيًا دوليًا يتتبع الشحنات عبر العالم. يستخدم التطبيق TypeScript لتطوير الواجهة الأمامية والخلفية. توفر الواجهة الأمامية واجهة مستخدم لتتبع الشحنات، بينما تتعامل الواجهة الخلفية مع معالجة البيانات والتكامل مع مختلف مزودي الشحن (مثل FedEx و DHL و UPS). تُستخدم حاويات Docker لنشر التطبيق في مراكز بيانات مختلفة حول العالم، مما يضمن زمن انتقال منخفض وتوافر عالي. يساعد TypeScript في ضمان اتساق نماذج البيانات المستخدمة لتتبع الشحنات، بينما يسهل Docker النشر السلس عبر البنى التحتية المتنوعة.

الخلاصة

يوفر دمج TypeScript مع Docker مجموعة قوية لبناء تطبيقات قوية وقابلة للصيانة. من خلال الاستفادة من سلامة النوع في TypeScript وقدرات حاويات Docker، يمكن للمطورين إنشاء تطبيقات أكثر موثوقية وأسهل في النشر وأكثر إنتاجية في التطوير. باتباع أفضل الممارسات الموضحة في هذا الدليل، يمكنك دمج TypeScript و Docker بشكل فعال في سير عمل التطوير الخاص بك وضمان سلامة الأنواع في الحاويات طوال دورة حياة التطوير.

مصادر إضافية

• موقع TypeScript الرسمي
• موقع Docker الرسمي
• وثائق Docker Compose