Docker இல் Node.js இல் "மிஸ்ஸிங் ஸ்டார்ட் ஸ்கிரிப்ட்" பிழையைத் தீர்க்கிறது

டோக்கரில் Node.js பின்தளத்தைத் தொடங்குதல்: ஒரு சிக்கலைத் தீர்க்கும் வழிகாட்டி

உங்கள் இயக்க முயற்சிக்கும்போது ஒரு பிழையை எதிர்கொள்கிறது Node.js பின்தளம் உள்ளே a டோக்கர் கொள்கலன் ஒரு எளிய "தொடக்க ஸ்கிரிப்ட் மிஸ்ஸிங்" செய்தியின் காரணமாக குறிப்பாக வெறுப்பாக இருக்கலாம். இந்த பிழை அடிக்கடி ஏற்படும் போது NPM உங்கள் அமைப்பில் சரியான தொடக்க கட்டளையை கண்டுபிடிக்க முடியவில்லை. நீங்கள் இதனால் பாதிக்கப்பட்டிருந்தால், நீங்கள் தனியாக இல்லை!

பல சமயங்களில், உங்கள் package.json மற்றும் Docker அமைப்புகளுக்கு இடையே தவறான பாதைகள் அல்லது தவறான உள்ளமைவுகளுக்குச் சிக்கல் ஏற்படுகிறது. கையாளும் போது ஒரு சிறிய விவரத்தை கவனிக்காமல் விடுவது எளிது பல கட்ட கட்டுமானங்கள், கண்டெய்னரைசேஷன் மற்றும் உள்ளமைவு கோப்புகள். இந்த சிக்கலை நானே எதிர்கொண்டதால், அதைச் சரிசெய்வது ஒவ்வொரு கோப்பின் இருப்பிடத்தையும் ஸ்கிரிப்ட்களையும் சரிபார்ப்பதை உள்ளடக்குகிறது என்று என்னால் சொல்ல முடியும்.

எடுத்துக்காட்டாக, நான் ஒரு முறை பின்தளத்தை பயன்படுத்தினேன், பின்னர் எனது டிஸ்ட் கோப்புறை சரியாக மேப் செய்யப்படவில்லை என்பதை உணர்ந்தேன், இதனால் தொடக்க கட்டளை தோல்வியடைகிறது. எளிய மாற்றங்களால் இந்தப் பிரச்சனைகளைத் தீர்க்க முடியும், ஆனால் சரியானதைக் கண்டறிவதற்கு பொறுமை தேவை 🔍. அனைத்து சார்புகள் மற்றும் ஸ்கிரிப்ட்கள் சரியாக வரைபடமாக்கப்பட்டுள்ளதா என்பதைச் சரிபார்ப்பது பிழைத்திருத்தத்தில் மணிநேரங்களைச் சேமிக்கும்.

இந்த வழிகாட்டியில், இந்தப் பிழையைச் சரிசெய்வதற்கான சில நடைமுறைப் படிகளில் மூழ்குவோம், குறிப்பாக உங்கள் பின்தளத்தை தரவுத்தளத்துடன் சேர்த்து இயக்கினால். டைனமோடிபி டோக்கரில். உங்கள் பின்தளம் சீராக இயங்க, "மிஸ்ஸிங் ஸ்டார்ட் ஸ்கிரிப்ட்" பிழையை ஒன்றாகச் சரிசெய்வோம்!

Node.js மற்றும் டேட்டாபேஸ் இணைப்புக்கான டோக்கர் உள்ளமைவு

மேலே உள்ள எடுத்துக்காட்டில், டோக்கர் அமைப்பு பல-நிலை கட்டமைப்பை மேம்படுத்துகிறது, இது திறமையான உற்பத்தி-தயாரான கொள்கலன்களை உருவாக்க பயனுள்ளதாக இருக்கும். முதல் நிலை, "பில்டர்" என வரையறுக்கப்படுகிறது, சார்புகளை நிறுவுகிறது மற்றும் தொகுக்கிறது டைப்ஸ்கிரிப்ட் இல் ஜாவாஸ்கிரிப்ட் கோப்புகள் மாவட்டம் கோப்புறை. தேவையற்ற dev சார்புகளைச் சேர்க்காமல் தொகுக்கப்பட்ட குறியீடு உற்பத்திக்குத் தயாராக இருப்பதை இந்தப் படி உறுதி செய்கிறது. கட்டப்பட்டதும், இரண்டாம் நிலை (இயக்க நேரம்) தொகுக்கப்பட்ட கோப்புகள் மற்றும் உற்பத்தி சார்புகளை மட்டுமே நகலெடுக்கிறது, கொள்கலன் அளவைக் குறைக்கிறது. ஒவ்வொரு பிட் தேர்வுமுறையும் கணக்கிடப்படும் கிளவுட் சூழல்களுக்கு நீங்கள் அடிக்கடி பயன்படுத்தினால், இந்த அமைப்பு குறிப்பாக உதவியாக இருக்கும்! 🚀

தி பணிப்பாளர் இரண்டு நிலைகளிலும் உள்ள கட்டளை, கொள்கலனின் செயல்பாட்டு கோப்பகத்தை /app என அமைக்கிறது. இது கோப்பு பாதைகளை எளிதாக்குகிறது மற்றும் இந்த கோப்பகத்தைச் சுற்றியுள்ள அனைத்து செயல்பாடுகளையும் ஒழுங்கமைக்கிறது. அதைத் தொடர்ந்து, நகலெடு அறிவுறுத்தல்கள் குறிப்பிட்ட கோப்புகளை ஹோஸ்ட் இயந்திரத்திலிருந்து கொள்கலனுக்கு நகர்த்துகின்றன. முதல் கட்டத்தில், சார்பு நிறுவல் மற்றும் டைப்ஸ்கிரிப்ட் தொகுப்பை அனுமதிக்க, தொகுப்பு*.json கோப்புகள் மற்றும் tsconfig.json ஆகியவை நகலெடுக்கப்படுகின்றன. npm நிறுவலை இயக்கவும் மற்றும் npm ரன் கட்டமைப்பை இயக்கவும் கட்டளைகள் அனைத்தும் சரியாக அமைக்கப்பட்டிருப்பதை உறுதி செய்கின்றன. எல்லா கோப்புகளும் சரியாக நகலெடுக்கப்பட்டு உள்ளமைக்கப்பட்டுள்ளதா என்பதை உறுதிசெய்வதன் மூலம் தொடக்க ஸ்கிரிப்ட்களை விடுவிப்பது போன்ற சிக்கல்களைத் தவிர்க்க இந்த அமைப்பு உதவுகிறது.

தி docker-compose.yml கோப்பு பின்தளத்தை இணைக்கிறது டைனமோடிபி, இது உள்ளூர் சோதனை மற்றும் மேம்பாட்டிற்கு அவசியம். தி சார்ந்தது பின்தளத்தில் இருந்து எந்த இணைப்பு முயற்சிக்கும் டேட்டாபேஸ் தயாராக இருப்பதை உறுதிசெய்து, பின்தள சேவைக்கு முன் DynamoDB ஐ தொடங்க விருப்பம் டோக்கரைச் சொல்கிறது. நிஜ உலகக் காட்சிகளில், அத்தகைய சார்பு அமைப்பு இல்லாதது, தரவுத்தளத்திற்கு முன் பின்தளம் தொடங்கும் போது இணைப்புச் சிக்கல்களுக்கு வழிவகுக்கும், இதன் விளைவாக ஏமாற்றமளிக்கும் பிழைகள் ஏற்படும். தி சுகாதார சோதனை இறுதிப்புள்ளியை பிங் செய்வதன் மூலம் DynamoDB ஐ அடைய முடியுமா என்பதை கட்டளை சோதனை செய்கிறது, ஒரு இணைப்பு நிறுவப்படும் வரை மீண்டும் முயற்சிக்கவும். இந்த அளவிலான பிழை கையாளுதல், சேவைகள் சரியான வரிசையில் தொடங்குவதை உறுதி செய்வதன் மூலம் நேரத்தை மிச்சப்படுத்துகிறது🕒.

இறுதியாக, pack.json இல், நாங்கள் வரையறுத்துள்ளோம் தொடங்கு என ஸ்கிரிப்ட் முனை dist/server.js. கண்டெய்னரில் எந்த கோப்பை இயக்க வேண்டும் என்பதை NPM சரியாக அறிந்திருப்பதை இந்தக் கட்டளை உறுதிசெய்கிறது, இது “மிஸ்ஸிங் ஸ்டார்ட் ஸ்கிரிப்ட்” பிழையைத் தவிர்க்க உதவுகிறது. டைப்ஸ்கிரிப்ட் குறியீட்டைத் தொகுக்க ஒரு உருவாக்க கட்டளையும், டிஸ்ட் கோப்புறையை அகற்ற ஒரு சுத்தமான கட்டளையும் உள்ளது, ஒவ்வொரு வரிசைப்படுத்தலும் புதிதாகத் தொடங்குவதை உறுதி செய்கிறது. இது போன்ற npm ஸ்கிரிப்ட்களைப் பயன்படுத்துவது, அமைப்பை மிகவும் நம்பகமானதாக ஆக்குகிறது, குறிப்பாக டோக்கர் ஈடுபடும் போது, ​​இது யூகிக்கக்கூடிய பாதைகள் மற்றும் செயல்களை வழங்குகிறது. டோக்கர், டோக்கர் கம்போஸ் மற்றும் என்பிஎம் ஸ்கிரிப்ட்களின் இந்த விரிவான உள்ளமைவு நெறிப்படுத்தப்பட்ட மேம்பாட்டிலிருந்து உற்பத்திக்கான பணிப்பாய்வுகளை உருவாக்க ஒன்றாகச் செயல்படுகிறது.

# Dockerfile
FROM node:18 AS builder
WORKDIR /app
# Copy necessary config files and install dependencies
COPY package*.json tsconfig.json ./
RUN npm install
# Copy all source files and build the project
COPY . .
RUN npm run build
# Production stage
FROM node:18-alpine
WORKDIR /app
COPY --from=builder /app/package*.json ./
RUN npm install --omit=dev
COPY --from=builder /app/dist ./dist
EXPOSE 3001
# Adjust command to start the server
CMD ["node", "dist/server.js"]

# docker-compose.yml
version: "3.9"
services:
  backend:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "3001:3001"
    environment:
      PORT: 3001
    depends_on:
      - dynamodb
    command: ["npm", "run", "start"]
  dynamodb:
    image: amazon/dynamodb-local
    ports:
      - "8001:8000"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000"]
      interval: 10s
      timeout: 5s
      retries: 5

{
  "name": "backend",
  "version": "1.0.0",
  "main": "dist/server.js",
  "scripts": {
    "build": "tsc",
    "start": "node dist/server.js",
    "dev": "nodemon --exec ts-node src/server.ts",
    "clean": "rimraf dist"
  }
}

// test/deployment.test.js
const fs = require('fs');
describe('Deployment Tests', () => {
  test('dist folder exists', () => {
    expect(fs.existsSync('./dist')).toBe(true);
  });
  test('start script exists in package.json', () => {
    const packageJson = require('../package.json');
    expect(packageJson.scripts.start).toBe("node dist/server.js");
  });
  test('Dockerfile has correct CMD', () => {
    const dockerfile = fs.readFileSync('./Dockerfile', 'utf8');
    expect(dockerfile).toMatch(/CMD \["node", "dist\/server.js"\]/);
  });
});

Node.js திட்டங்களுக்கான டோக்கரில் சரியான கோப்பு நகலெடுப்பு மற்றும் கட்டமைப்பை உறுதி செய்தல்

Docker இல் Node.js பயன்பாடுகளுடன் பணிபுரியும் போது, ​​தேவையான அனைத்து கோப்புகளும் கொள்கலனில் சரியாக நகலெடுக்கப்பட்டு கட்டமைக்கப்படுவதை ஒரு முக்கிய கருத்தில் கொள்ள வேண்டும். மேலே உள்ள எடுத்துக்காட்டைப் போலவே பல-நிலை உருவாக்கங்களில், ஒவ்வொரு கட்டத்திற்கும் ஒரு குறிப்பிட்ட நோக்கம் உள்ளது. ஆரம்ப நிலை, "பில்டர்," ஜாவாஸ்கிரிப்ட்டில் டைப்ஸ்கிரிப்ட் தொகுப்பதைக் கையாளுகிறது மற்றும் அதைத் தயாரிக்கிறது மாவட்டம் கோப்புறை. இரண்டாவது கட்டத்தில், தயாரிப்பு கோப்புகள் மட்டுமே சேர்க்கப்பட்டுள்ளன, கொள்கலன் அளவைக் குறைத்து, வரிசைப்படுத்தலை மேம்படுத்துகிறது. இந்த அணுகுமுறை தேவையற்ற வீக்கத்தைக் குறைப்பது மட்டுமல்லாமல், மேம்பாட்டுக் கருவிகளை விட்டுவிட்டு பாதுகாப்பையும் அதிகரிக்கிறது.

Node.js க்கான டோக்கரின் இன்றியமையாத அம்சம் ஏற்பாடு செய்வதாகும் pack.json மற்றும் தொடக்க ஸ்கிரிப்ட் துல்லியமாக. Dockerfile இல் பாதைகளைத் தெளிவாகக் குறிப்பிடுவதன் மூலமும், தொடக்கக் கட்டளை சரியாக அமைக்கப்பட்டுள்ளதை உறுதி செய்வதன் மூலமும் pack.json, "தொடக்க ஸ்கிரிப்ட் காணவில்லை" போன்ற பிழைகளைக் குறைக்கிறீர்கள். குறிப்பாக பல சேவைகள் அல்லது கோப்புறைகளை உள்ளடக்கிய சிக்கலான அமைப்புகளில், ஒவ்வொரு கோப்பும் எங்கு இருக்க வேண்டும் என்பதை டோக்கருக்குத் தெரியும் என்பதை உறுதிப்படுத்துவதும் முக்கியமானது. எடுத்துக்காட்டாக, COPY கட்டளையை மட்டும் சேர்க்க மாவட்டம் கோப்புறை மற்றும் இறுதி கொள்கலனுக்கு தேவையான உள்ளமைவுகள் தயாரிப்பில் அத்தியாவசிய கோப்புகள் மட்டுமே இருப்பதை உறுதி செய்கிறது 📂.

உங்கள் சேவைகளின் ஆரோக்கியத்தை சரிபார்க்க, தி docker-compose.yml தரவுத்தளம் தயாராக உள்ளதா என்பதைச் சரிபார்க்க கோப்பு ஒரு சுகாதார சோதனையைப் பயன்படுத்துகிறது. சார்புகளை வரையறுப்பதன் மூலம், தரவுத்தளம் பதிலளிக்கும் வரை பின்தள சேவை தொடங்காது என்பதை உறுதிசெய்கிறோம், நேரம் தொடர்பான இணைப்புச் சிக்கல்களைத் தடுக்கிறோம். தரவுத்தள இணைப்பு இன்றியமையாத நிஜ-உலகப் பயன்பாடுகளில் இந்த அமைப்பு மிகவும் பயனுள்ளதாக இருக்கும். இந்த அமைப்பு இல்லாமல், பிற சேவைகள் தொடங்கும் முன் சேவைகள் இணைக்க முயற்சி செய்யலாம், இது இயக்க நேரப் பிழைகள் மற்றும் பயனர்களுக்கு சாத்தியமான வேலையில்லா நேரங்களுக்கு வழிவகுக்கும் 🔄.