ஜாவாஸ்கிரிப்ட் மேம்பாட்டுச் சூழல்: டாக்கர் கொள்கலன் கட்டமைப்பு

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

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

ஜாவாஸ்கிரிப்ட் மேம்பாட்டிற்கு டாக்கரைப் ஏன் பயன்படுத்த வேண்டும்?

விவரங்களுக்குள் செல்வதற்கு முன், உங்கள் ஜாவாஸ்கிரிப்ட் மேம்பாட்டுச் சூழலுக்காக டாக்கரைப் பயன்படுத்துவதன் நன்மைகளை ஆராய்வோம்:

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

முன் தேவைகள்

நீங்கள் தொடங்குவதற்கு முன், பின்வருவனவற்றை நிறுவியுள்ளீர்கள் என்பதை உறுதிப்படுத்திக் கொள்ளுங்கள்:

• டாக்கர்: அதிகாரப்பூர்வ டாக்கர் வலைத்தளத்திலிருந்து (docker.com) உங்கள் இயக்க முறைமைக்கு டாக்கர் டெஸ்க்டாப்பைப் பதிவிறக்கி நிறுவவும். டாக்கர் டெஸ்க்டாப்பில் டாக்கர் எஞ்சின், டாக்கர் CLI, டாக்கர் கம்போஸ் மற்றும் பிற அத்தியாவசிய கருவிகள் உள்ளன.
• Node.js மற்றும் npm (விருப்பத்தேர்வு): உங்கள் ஹோஸ்ட் கணினியில் கண்டிப்பாகத் தேவையில்லை என்றாலும், அவை கொள்கலனுக்குள் இருக்கும் என்பதால், Node.js மற்றும் npm உள்ளூரில் நிறுவியிருப்பது கொள்கலனுக்கு வெளியே உள்ள பணிகளுக்கு அல்லது உங்கள் ஆரம்ப திட்ட கட்டமைப்பை அமைக்கும்போது உதவியாக இருக்கும். அவற்றை nodejs.org இலிருந்து பதிவிறக்கம் செய்யலாம்.
• ஒரு கோட் எடிட்டர்: உங்களுக்கு விருப்பமான கோட் எடிட்டரைத் தேர்வு செய்யவும் (எ.கா., VS Code, Sublime Text, Atom). VS Code சிறந்த டாக்கர் நீட்டிப்புகளைக் கொண்டுள்ளது, இது உங்கள் பணிப்பாய்வை எளிதாக்கும்.

அடிப்படை Dockerfile கட்டமைப்பு

எந்தவொரு டாக்கர் அடிப்படையிலான சூழலின் அடித்தளமும் Dockerfile ஆகும். இந்த கோப்பு உங்கள் டாக்கர் பிம்பத்தை உருவாக்குவதற்கான வழிமுறைகளைக் கொண்டுள்ளது. ஒரு Node.js பயன்பாட்டிற்கான ஒரு அடிப்படை 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 application dependencies
RUN npm install

# Copy the application source code to the working directory
COPY . .

# Expose port 3000 to the outside world (adjust if your app uses a different port)
EXPOSE 3000

# Define the command to run when the container starts
CMD ["npm", "start"]

ஒவ்வொரு வரியையும் விரிவாகப் பார்ப்போம்:

• FROM node:18-alpine: கொள்கலனுக்கான அடிப்படை பிம்பத்தைக் குறிப்பிடுகிறது. இந்த விஷயத்தில், நாங்கள் அதிகாரப்பூர்வ Node.js 18 Alpine பிம்பத்தைப் பயன்படுத்துகிறோம், இது ஒரு இலகுரக லினக்ஸ் விநியோகம் ஆகும். Alpine அதன் சிறிய அளவுக்காக அறியப்படுகிறது, இது உங்கள் டாக்கர் பிம்பத்தை சிறியதாக வைத்திருக்க உதவுகிறது. உங்கள் திட்டத்திற்குப் பொருத்தமான பிற Node.js பதிப்புகளைக் கவனியுங்கள்.
• WORKDIR /app: கொள்கலனுக்குள் வேலை செய்யும் கோப்பகத்தை /app ஆக அமைக்கிறது. இங்கேதான் உங்கள் பயன்பாட்டுக் குறியீடு இருக்கும்.
• COPY package*.json ./: package.json மற்றும் package-lock.json (அல்லது நீங்கள் Yarn பயன்படுத்தினால் yarn.lock) கோப்புகளை வேலை செய்யும் கோப்பகத்திற்கு நகலெடுக்கிறது. இந்த கோப்புகளை முதலில் நகலெடுப்பது டாக்கரை npm install படியை கேச் செய்ய அனுமதிக்கிறது, நீங்கள் பயன்பாட்டுக் குறியீட்டை மட்டும் மாற்றும்போது பில்ட் நேரத்தை கணிசமாக வேகப்படுத்துகிறது.
• RUN npm install: package.json இல் வரையறுக்கப்பட்ட பயன்பாட்டு சார்புகளை நிறுவுகிறது.
• COPY . .: உங்கள் உள்ளூர் திட்டக் கோப்பகத்திலிருந்து மீதமுள்ள அனைத்து கோப்புகளையும் கோப்பகங்களையும் கொள்கலனுக்குள் உள்ள வேலை செய்யும் கோப்பகத்திற்கு நகலெடுக்கிறது.
• EXPOSE 3000: போர்ட் 3000-ஐ வெளிப்படுத்துகிறது, இது ஹோஸ்ட் கணினியிலிருந்து அணுகக்கூடியதாக ஆக்குகிறது. உங்கள் பயன்பாடு இந்த போர்ட்டில் கேட்டால் இது முக்கியம். உங்கள் பயன்பாடு வேறு போர்ட்டைப் பயன்படுத்தினால் போர்ட் எண்ணை சரிசெய்யவும்.
• CMD ["npm", "start"]: கொள்கலன் தொடங்கும் போது இயக்க வேண்டிய கட்டளையைக் குறிப்பிடுகிறது. இந்த விஷயத்தில், நாங்கள் npm start ஐப் பயன்படுத்துகிறோம், இது Node.js பயன்பாடுகளைத் தொடங்குவதற்கான ஒரு பொதுவான கட்டளையாகும். இந்த கட்டளை உங்கள் package.json இன் scripts பிரிவில் வரையறுக்கப்பட்ட கட்டளையுடன் பொருந்துகிறதா என்பதை உறுதிப்படுத்தவும்.

டாக்கர் பிம்பத்தை உருவாக்குதல்

உங்கள் Dockerfile ஐ உருவாக்கியதும், பின்வரும் கட்டளையைப் பயன்படுத்தி டாக்கர் பிம்பத்தை உருவாக்கலாம்:

docker build -t my-node-app .

இதில்:

• docker build: பிம்பங்களை உருவாக்குவதற்கான டாக்கர் கட்டளை.
• -t my-node-app: பிம்பத்திற்கான குறிச்சொல்லை (பெயர்) குறிப்பிடுகிறது. உங்கள் பயன்பாட்டிற்கு ஒரு விளக்கமான பெயரைத் தேர்வு செய்யவும்.
• .: பில்ட் சூழலைக் குறிப்பிடுகிறது, இது தற்போதைய கோப்பகம் ஆகும். டாக்கர் இந்த கோப்பகத்தில் உள்ள Dockerfile ஐப் பயன்படுத்தி பிம்பத்தை உருவாக்கும்.

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

டாக்கர் கொள்கலனை இயக்குதல்

பிம்பம் உருவாக்கப்பட்ட பிறகு, பின்வரும் கட்டளையைப் பயன்படுத்தி அதிலிருந்து ஒரு கொள்கலனை இயக்கலாம்:

docker run -p 3000:3000 my-node-app

இதில்:

• docker run: கொள்கலன்களை இயக்குவதற்கான டாக்கர் கட்டளை.
• -p 3000:3000: ஹோஸ்ட் கணினியில் உள்ள போர்ட் 3000 ஐ கொள்கலனுக்குள் உள்ள போர்ட் 3000 உடன் மேப் செய்கிறது. இது உங்கள் உலாவியில் இருந்து localhost:3000 ஐப் பயன்படுத்தி உங்கள் பயன்பாட்டை அணுக உங்களை அனுமதிக்கிறது. முதல் எண் ஹோஸ்ட் போர்ட், இரண்டாவது எண் கொள்கலன் போர்ட் ஆகும்.
• my-node-app: நீங்கள் இயக்க விரும்பும் பிம்பத்தின் பெயர்.

உங்கள் பயன்பாடு இப்போது டாக்கர் கொள்கலனுக்குள் இயங்க வேண்டும். உங்கள் உலாவியைத் திறந்து localhost:3000 (அல்லது நீங்கள் குறிப்பிட்ட போர்ட்) க்குச் செல்வதன் மூலம் அதை அணுகலாம். உங்கள் பயன்பாட்டின் வரவேற்புத் திரை அல்லது ஆரம்ப UI ஐ நீங்கள் பார்க்க வேண்டும்.

டாக்கர் கம்போஸ் பயன்படுத்துதல்

பல சேவைகளைக் கொண்ட மிகவும் சிக்கலான பயன்பாடுகளுக்கு, டாக்கர் கம்போஸ் ஒரு விலைமதிப்பற்ற கருவியாகும். இது ஒரு YAML கோப்பைப் பயன்படுத்தி பல-கொள்கலன் பயன்பாடுகளை வரையறுத்து நிர்வகிக்க உங்களை அனுமதிக்கிறது. எங்கள் Node.js பயன்பாட்டிற்காக ஒரு docker-compose.yml கோப்பை உருவாக்குவோம்:

version: "3.9"
services:
  app:
    build: .
    ports:
      - "3000:3000"
    volumes:
      - .:/app
    environment:
      NODE_ENV: development
    command: npm run dev

ஒவ்வொரு பகுதியையும் ஆராய்வோம்:

• version: "3.9": டாக்கர் கம்போஸ் கோப்பு வடிவத்தின் பதிப்பைக் குறிப்பிடுகிறது.
• services: உங்கள் பயன்பாட்டை உருவாக்கும் சேவைகளை வரையறுக்கிறது. இந்த விஷயத்தில், எங்களிடம் app என்ற பெயரில் ஒரு சேவை உள்ளது.
• build: .: தற்போதைய கோப்பகத்தில் உள்ள Dockerfile இலிருந்து பிம்பம் உருவாக்கப்பட வேண்டும் என்பதைக் குறிப்பிடுகிறது.
• ports: - "3000:3000": docker run கட்டளையைப் போலவே, ஹோஸ்ட் கணினியில் உள்ள போர்ட் 3000 ஐ கொள்கலனுக்குள் உள்ள போர்ட் 3000 உடன் மேப் செய்கிறது.
• volumes: - .:/app: உங்கள் ஹோஸ்ட் கணினியில் உள்ள தற்போதைய கோப்பகத்தை கொள்கலனுக்குள் உள்ள /app கோப்பகத்துடன் இணைக்கும் ஒரு வால்யூமை உருவாக்குகிறது. இது உங்கள் ஹோஸ்ட் கணினியில் உங்கள் குறியீட்டில் மாற்றங்களைச் செய்ய உங்களை அனுமதிக்கிறது, மேலும் அவை கொள்கலனுக்குள் தானாகவே பிரதிபலிக்கின்றன, இது ஹாட் ரீலோடிங்கை செயல்படுத்துகிறது.
• environment: NODE_ENV: development: கொள்கலனுக்குள் NODE_ENV சூழல் மாறியை development ஆக அமைக்கிறது. இது உங்கள் பயன்பாட்டை மேம்பாட்டு பயன்முறையில் இயக்க கட்டமைக்க பயனுள்ளதாக இருக்கும்.
• command: npm run dev: Dockerfile இல் வரையறுக்கப்பட்ட இயல்புநிலை கட்டளையை மீறுகிறது. இந்த விஷயத்தில், நாங்கள் npm run dev ஐப் பயன்படுத்துகிறோம், இது பெரும்பாலும் ஹாட் ரீலோடிங்குடன் ஒரு மேம்பாட்டு சேவையகத்தைத் தொடங்கப் பயன்படுகிறது.

டாக்கர் கம்போஸைப் பயன்படுத்தி பயன்பாட்டைத் தொடங்க, docker-compose.yml கோப்பைக் கொண்ட கோப்பகத்திற்குச் சென்று பின்வரும் கட்டளையை இயக்கவும்:

docker-compose up

டாக்கர் கம்போஸ் பிம்பத்தை (தேவைப்பட்டால்) உருவாக்கி கொள்கலனைத் தொடங்கும். -d கொடியை கொள்கலனைப் பிரிந்த பயன்முறையில் (பின்னணியில்) இயக்கச் சேர்க்கலாம்.

மேம்பட்ட கட்டமைப்பு விருப்பங்கள்

உங்கள் டாக்கரைஸ் செய்யப்பட்ட ஜாவாஸ்கிரிப்ட் மேம்பாட்டுச் சூழலை மேம்படுத்த சில மேம்பட்ட கட்டமைப்பு விருப்பங்கள் இங்கே:

1. பல-கட்ட பில்டுகள்

பல-கட்ட பில்டுகள் உங்கள் Dockerfile இல் பல FROM வழிமுறைகளைப் பயன்படுத்த உங்களை அனுமதிக்கின்றன, ஒவ்வொன்றும் வெவ்வேறு பில்ட் கட்டத்தைக் குறிக்கின்றன. இது பில்ட் சூழலை இயக்க நேர சூழலிலிருந்து பிரிப்பதன் மூலம் உங்கள் இறுதி பிம்பத்தின் அளவைக் குறைக்க பயனுள்ளதாக இருக்கும்.

# Stage 1: Build the application
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# Stage 2: Create the runtime image
FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

இந்த எடுத்துக்காட்டில், முதல் கட்டம் (builder) Node.js ஐப் பயன்படுத்தி பயன்பாட்டை உருவாக்குகிறது. இரண்டாவது கட்டம் உருவாக்கப்பட்ட பயன்பாட்டுக் கோப்புகளை வழங்க Nginx ஐப் பயன்படுத்துகிறது. முதல் கட்டத்திலிருந்து உருவாக்கப்பட்ட கோப்புகள் மட்டுமே இரண்டாவது கட்டத்திற்கு நகலெடுக்கப்படுகின்றன, இதன் விளைவாக ஒரு சிறிய மற்றும் திறமையான பிம்பம் உருவாகிறது.

2. சூழல் மாறிகளைப் பயன்படுத்துதல்

குறியீட்டை மாற்றாமல் உங்கள் பயன்பாட்டைக் கட்டமைக்க சூழல் மாறிகள் ஒரு சக்திவாய்ந்த வழியாகும். உங்கள் docker-compose.yml கோப்பில் சூழல் மாறிகளை வரையறுக்கலாம் அல்லது -e கொடியைப் பயன்படுத்தி இயக்க நேரத்தில் அவற்றை அனுப்பலாம்.

services:
  app:
    environment:
      API_URL: "http://api.example.com"

உங்கள் பயன்பாட்டிற்குள், process.env ஐப் பயன்படுத்தி இந்த சூழல் மாறிகளை அணுகலாம்.

const apiUrl = process.env.API_URL;

3. மேம்பாட்டிற்கான வால்யூம் மவுண்டிங்

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

4. VS Code உடன் பிழைதிருத்தம் செய்தல்

டாக்கர் கொள்கலன்களுக்குள் இயங்கும் Node.js பயன்பாடுகளைப் பிழைதிருத்தம் செய்வதற்கு VS Code சிறந்த ஆதரவைக் கொண்டுள்ளது. இயங்கும் கொள்கலனுடன் இணைக்க மற்றும் பிரேக் பாயிண்ட்டுகளை அமைக்க, மாறிகளை ஆய்வு செய்ய மற்றும் உங்கள் குறியீட்டின் வழியாகச் செல்ல VS Code டாக்கர் நீட்டிப்பைப் பயன்படுத்தலாம்.

முதலில், VS Code இல் டாக்கர் நீட்டிப்பை நிறுவவும். பின்னர், உங்கள் .vscode கோப்பகத்தில் பின்வரும் உள்ளமைவுடன் ஒரு launch.json கோப்பை உருவாக்கவும்:

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "node",
      "request": "attach",
      "name": "Attach to Docker",
      "port": 9229,
      "address": "localhost",
      "remoteRoot": "/app",
      "localRoot": "${workspaceFolder}"
    }
  ]
}

உங்கள் Node.js பயன்பாடு --inspect அல்லது --inspect-brk கொடியுடன் தொடங்கப்பட்டுள்ளதா என்பதை உறுதிப்படுத்தவும். எடுத்துக்காட்டாக, இந்த கொடியை சேர்க்க உங்கள் docker-compose.yml கோப்பை மாற்றியமைக்கலாம்:

services:
  app:
    command: npm run dev -- --inspect=0.0.0.0:9229

பின்னர், VS Code இல், "Attach to Docker" உள்ளமைவைத் தேர்ந்தெடுத்து பிழைதிருத்தத்தைத் தொடங்கவும். நீங்கள் பிரேக் பாயிண்ட்டுகளை அமைக்க முடியும் மற்றும் கொள்கலனுக்குள் இயங்கும் உங்கள் குறியீட்டைப் பிழைதிருத்தம் செய்ய முடியும்.

5. ஒரு தனியார் npm பதிவகத்தைப் பயன்படுத்துதல்

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

# Dockerfile
FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
COPY .npmrc .
RUN npm install
COPY . .
EXPOSE 3000
CMD ["npm", "start"]

.npmrc கோப்பில் உங்கள் அங்கீகார டோக்கன் இருக்க வேண்டும்:

//registry.npmjs.org/:_authToken=YOUR_NPM_TOKEN

YOUR_NPM_TOKEN ஐ உங்கள் உண்மையான npm டோக்கனுடன் மாற்றுவதை நினைவில் கொள்ளுங்கள். இந்த டோக்கனைப் பாதுகாப்பாக வைத்திருங்கள் மற்றும் அதை உங்கள் பொது களஞ்சியத்தில் சமர்ப்பிக்க வேண்டாம்.

6. பிம்ப அளவை மேம்படுத்துதல்

வேகமான பில்ட் மற்றும் வரிசைப்படுத்தல் நேரங்களுக்கு உங்கள் டாக்கர் பிம்பத்தின் அளவை சிறியதாக வைத்திருப்பது முக்கியம். பிம்ப அளவை மேம்படுத்துவதற்கான சில குறிப்புகள் இங்கே:

• node:alpine போன்ற ஒரு இலகுரக அடிப்படை பிம்பத்தைப் பயன்படுத்தவும்.
• பில்ட் சூழலை இயக்க நேர சூழலிலிருந்து பிரிக்க பல-கட்ட பில்டுகளைப் பயன்படுத்தவும்.
• பிம்பத்திலிருந்து தேவையற்ற கோப்புகள் மற்றும் கோப்பகங்களை அகற்றவும்.
• பில்ட் சூழலிலிருந்து கோப்புகள் மற்றும் கோப்பகங்களை விலக்க .dockerignore கோப்பைப் பயன்படுத்தவும்.
• அடுக்குகளின் எண்ணிக்கையைக் குறைக்க பல RUN கட்டளைகளை ஒரே கட்டளையாக இணைக்கவும்.

எடுத்துக்காட்டு: ஒரு React பயன்பாட்டை டாக்கரைஸ் செய்தல்

Create React App உடன் உருவாக்கப்பட்ட ஒரு React பயன்பாட்டை டாக்கரைஸ் செய்வதன் மூலம் இந்த கருத்துக்களை ஒரு நடைமுறை எடுத்துக்காட்டுடன் விளக்குவோம்.

முதலில், Create React App ஐப் பயன்படுத்தி ஒரு புதிய React பயன்பாட்டை உருவாக்கவும்:

npx create-react-app my-react-app
cd my-react-app

பின்னர், திட்டத்தின் ரூட் கோப்பகத்தில் ஒரு Dockerfile ஐ உருவாக்கவும்:

FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

FROM nginx:alpine
COPY --from=builder /app/build /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

ஒரு docker-compose.yml கோப்பை உருவாக்கவும்:

version: "3.9"
services:
  app:
    build: .
    ports:
      - "3000:80"
    volumes:
      - .:/app
    environment:
      NODE_ENV: development

குறிப்பு: நாங்கள் ஹோஸ்டில் உள்ள போர்ட் 3000 ஐ கொள்கலனுக்குள் உள்ள போர்ட் 80 க்கு மேப் செய்கிறோம், ஏனெனில் Nginx போர்ட் 80 இல் பயன்பாட்டை வழங்குகிறது. உங்கள் பயன்பாட்டின் உள்ளமைவைப் பொறுத்து நீங்கள் போர்ட் மேப்பிங்கை சரிசெய்ய வேண்டியிருக்கலாம்.

இறுதியாக, பயன்பாட்டை உருவாக்கித் தொடங்க docker-compose up ஐ இயக்கவும். பின்னர் உங்கள் உலாவியில் localhost:3000 க்குச் செல்வதன் மூலம் பயன்பாட்டை அணுகலாம்.

பொதுவான சிக்கல்கள் மற்றும் சரிசெய்தல்

கவனமான உள்ளமைவுடன் கூட, டாக்கருடன் பணிபுரியும்போது நீங்கள் சிக்கல்களை சந்திக்க நேரிடலாம். இங்கே சில பொதுவான சிக்கல்களும் அவற்றின் தீர்வுகளும் உள்ளன:

• போர்ட் முரண்பாடுகள்: உங்கள் docker-compose.yml அல்லது docker run கட்டளையில் நீங்கள் மேப் செய்யும் போர்ட்கள் உங்கள் ஹோஸ்ட் கணினியில் உள்ள பிற பயன்பாடுகளால் ஏற்கனவே பயன்படுத்தப்படவில்லை என்பதை உறுதிப்படுத்தவும்.
• வால்யூம் மவுண்டிங் சிக்கல்கள்: நீங்கள் மவுண்ட் செய்யும் கோப்புகள் மற்றும் கோப்பகங்களில் உள்ள அனுமதிகளைச் சரிபார்க்கவும். கோப்புகளை அணுக டாக்கருக்குத் தேவையான அனுமதிகள் இல்லாமல் இருக்கலாம்.
• பிம்ப பில்ட் தோல்விகள்: பிழைகளுக்கு docker build கட்டளையின் வெளியீட்டை கவனமாக ஆராயுங்கள். தவறான Dockerfile தொடரியல், விடுபட்ட சார்புகள் அல்லது நெட்வொர்க் சிக்கல்கள் பொதுவான காரணங்கள்.
• கொள்கலன் செயலிழப்புகள்: உங்கள் கொள்கலனின் பதிவுகளைக் காண docker logs கட்டளையைப் பயன்படுத்தி செயலிழப்புக்கான காரணத்தைக் கண்டறியவும். பயன்பாட்டுப் பிழைகள், விடுபட்ட சூழல் மாறிகள் அல்லது வளக் கட்டுப்பாடுகள் பொதுவான காரணங்கள்.
• மெதுவான பில்ட் நேரங்கள்: பல-கட்ட பில்டுகளைப் பயன்படுத்துதல், சார்புகளை கேச் செய்தல் மற்றும் அடுக்குகளின் எண்ணிக்கையைக் குறைத்தல் ஆகியவற்றின் மூலம் உங்கள் Dockerfile ஐ மேம்படுத்தவும்.

முடிவுரை

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

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

அடுத்த படிகள்:

• உங்கள் குறிப்பிட்ட தேவைகளுக்குப் பொருந்தக்கூடிய முன்-கட்டமைக்கப்பட்ட பிம்பங்களுக்கு டாக்கர் ஹப்பை ஆராயுங்கள்.
• பல-கொள்கலன் பயன்பாடுகளை நிர்வகிப்பதற்கு டாக்கர் கம்போஸில் ஆழமாகச் செல்லுங்கள்.
• உற்பத்தி சூழல்களில் டாக்கர் கொள்கலன்களை ஒருங்கிணைக்க டாக்கர் ஸ்வார்ம் மற்றும் குபெர்னெட்ஸ் பற்றி அறிக.

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