જાવાસ્ક્રિપ્ટ ડેવલપમેન્ટ એન્વાયર્નમેન્ટ: ડોકર કન્ટેનર રૂપરેખાંકન

આજના ઝડપી ગતિશીલ સોફ્ટવેર ડેવલપમેન્ટ લેન્ડસ્કેપમાં, સુસંગત અને પુનઃઉત્પાદન કરી શકાય તેવા ડેવલપમેન્ટ એન્વાયર્નમેન્ટને જાળવવું ખૂબ જ મહત્વપૂર્ણ છે. વિવિધ ઓપરેટિંગ સિસ્ટમ્સ, બદલાતા સોફ્ટવેર વર્ઝન અને વિરોધાભાસી નિર્ભરતા "તે મારા મશીન પર કામ કરે છે" સિન્ડ્રોમ તરફ દોરી શકે છે. ડોકર, એક અગ્રણી કન્ટેનરાઇઝેશન પ્લેટફોર્મ, આ સમસ્યાનો એક શક્તિશાળી ઉકેલ પૂરો પાડે છે, જે ડેવલપર્સને તેમની એપ્લિકેશન અને તેની નિર્ભરતાને એક જ, અલગ એકમમાં પેકેજ કરવાની મંજૂરી આપે છે.

આ માર્ગદર્શિકા તમને ડોકર કન્ટેનરનો ઉપયોગ કરીને મજબૂત અને સુસંગત જાવાસ્ક્રિપ્ટ ડેવલપમેન્ટ એન્વાયર્નમેન્ટ સેટ કરવાની પ્રક્રિયામાં લઈ જશે. અમે તમારા JavaScript પ્રોજેક્ટ્સ માટે સરળ અને કાર્યક્ષમ વર્કફ્લો સુનિશ્ચિત કરીને, મૂળભૂત સેટઅપથી લઈને અદ્યતન રૂપરેખાંકનો સુધીની દરેક બાબતોને આવરી લઈશું, પછી ભલે તમારી ટીમની વિવિધ ઓપરેટિંગ સિસ્ટમ્સ હોય.

જાવાસ્ક્રિપ્ટ ડેવલપમેન્ટ માટે ડોકરનો ઉપયોગ શા માટે કરવો?

વિશિષ્ટતાઓમાં ડાઇવિંગ કરતા પહેલા, ચાલો તમારા જાવાસ્ક્રિપ્ટ ડેવલપમેન્ટ એન્વાયર્નમેન્ટ માટે ડોકરનો ઉપયોગ કરવાના ફાયદાઓનું અન્વેષણ કરીએ:

• સુસંગતતા: ડોકર સુનિશ્ચિત કરે છે કે તમારી ટીમમાં દરેક વ્યક્તિ એક જ એન્વાયર્નમેન્ટ સાથે કામ કરે છે, જે સુસંગતતા સમસ્યાઓને દૂર કરે છે અને એન્વાયર્નમેન્ટના તફાવતોને કારણે થતી ભૂલોની શક્યતા ઘટાડે છે. આ ખાસ કરીને ભૌગોલિક રીતે વિતરિત ટીમો માટે મહત્વપૂર્ણ છે.
• આઇસોલેશન: કન્ટેનર હોસ્ટ સિસ્ટમથી આઇસોલેશન પ્રદાન કરે છે, અન્ય પ્રોજેક્ટ્સ સાથેના સંઘર્ષને અટકાવે છે અને ખાતરી કરે છે કે તમારી નિર્ભરતા એકબીજા સાથે દખલ ન કરે.
• પુનઃઉત્પાદનક્ષમતા: ડોકર છબીઓને સરળતાથી શેર અને જમાવી શકાય છે, જે વિવિધ મશીનો પર અથવા ઉત્પાદનમાં તમારા ડેવલપમેન્ટ એન્વાયર્નમેન્ટને પુનઃઉત્પાદન કરવાનું સરળ બનાવે છે. નવા ટીમના સભ્યોને ઓનબોર્ડ કરતી વખતે અથવા વિવિધ ક્લાઉડ પ્રદાતાઓને જમા કરતી વખતે આ ખાસ કરીને મદદરૂપ થાય છે.
• પોર્ટેબિલિટી: ડોકર કન્ટેનર કોઈપણ પ્લેટફોર્મ પર ચાલી શકે છે જે ડોકરને સપોર્ટ કરે છે, જેમાં વિન્ડોઝ, મOSકોએસ અને લિનક્સનો સમાવેશ થાય છે, જે ડેવલપર્સને પ્રોજેક્ટને અસર કર્યા વિના તેમની પસંદગીની ઓપરેટિંગ સિસ્ટમનો ઉપયોગ કરવાની મંજૂરી આપે છે.
• સરળીકૃત જમાવટ: ડેવલપમેન્ટ માટે વપરાતી સમાન ડોકર ઇમેજ પરીક્ષણ અને ઉત્પાદન માટે વાપરી શકાય છે, જમાવટની પ્રક્રિયાને સુવ્યવસ્થિત કરે છે અને ભૂલોનું જોખમ ઘટાડે છે.

પૂર્વજરૂરીયાતો

તમે પ્રારંભ કરો તે પહેલાં, ખાતરી કરો કે તમારી પાસે નીચેના ઇન્સ્ટોલ કરેલા છે:

• ડોકર: સત્તાવાર ડોકર વેબસાઇટ (docker.com) પરથી તમારી ઓપરેટિંગ સિસ્ટમ માટે ડોકર ડેસ્કટોપ ડાઉનલોડ અને ઇન્સ્ટોલ કરો. ડોકર ડેસ્કટોપમાં ડોકર એન્જિન, ડોકર સીએલઆઈ, ડોકર કમ્પોઝ અને અન્ય આવશ્યક સાધનો શામેલ છે.
• Node.js અને npm (વૈકલ્પિક): જ્યારે તમારા હોસ્ટ મશીનમાં સખત રીતે આવશ્યક ન હોય કારણ કે તે કન્ટેનરની અંદર હશે, ત્યારે સ્થાનિક રીતે Node.js અને npm ઇન્સ્ટોલ કરવું એ કન્ટેનરની બહારના કાર્યો માટે અથવા જ્યારે તમારી પ્રારંભિક પ્રોજેક્ટ સ્ટ્રક્ચર સેટ કરી રહ્યા હોય ત્યારે મદદરૂપ થઈ શકે છે. તમે તેને nodejs.org પરથી ડાઉનલોડ કરી શકો છો.
• કોડ એડિટર: તમારું પસંદ કરેલું કોડ એડિટર પસંદ કરો (ઉદાહરણ તરીકે, વીએસ કોડ, સબલાઈમ ટેક્સ્ટ, એટમ). વીએસ કોડમાં ઉત્તમ ડોકર એક્સ્ટેન્શન્સ છે જે તમારા વર્કફ્લોને સરળ બનાવી શકે છે.

મૂળભૂત ડોકરફાઈલ રૂપરેખાંકન

કોઈપણ ડોકર આધારિત એન્વાયર્નમેન્ટનો પાયો Dockerfile છે. આ ફાઇલમાં તમારી ડોકર છબી બનાવવા માટેની સૂચનાઓ છે. ચાલો નોડ.જેએસ એપ્લિકેશન માટે મૂળભૂત Dockerfile બનાવીએ:

# પિતૃ છબી તરીકે સત્તાવાર Node.js રનટાઇમનો ઉપયોગ કરો
FROM node:18-alpine

# કન્ટેનરમાં કાર્યકારી ડિરેક્ટરી સેટ કરો
WORKDIR /app

# package.json અને package-lock.json ને કાર્યકારી ડિરેક્ટરીમાં કૉપિ કરો
COPY package*.json ./

# એપ્લિકેશન નિર્ભરતા સ્થાપિત કરો
RUN npm install

# એપ્લિકેશન સોર્સ કોડને કાર્યકારી ડિરેક્ટરીમાં કૉપિ કરો
COPY .\t.

# બહારની દુનિયામાં પોર્ટ 3000 ને એક્સપોઝ કરો (જો તમારી એપ્લિકેશન અલગ પોર્ટનો ઉપયોગ કરે તો તેને સમાયોજિત કરો)
EXPOSE 3000

# જ્યારે કન્ટેનર શરૂ થાય ત્યારે ચલાવવા માટે આદેશ વ્યાખ્યાયિત કરો
CMD ["npm", "start"]

ચાલો દરેક લાઇન તોડીએ:

• FROM node:18-alpine: કન્ટેનર માટે આધાર છબી સ્પષ્ટ કરે છે. આ કિસ્સામાં, અમે સત્તાવાર Node.js 18 Alpine ઇમેજનો ઉપયોગ કરી રહ્યા છીએ, જે એક હળવા Linux વિતરણ છે. Alpine તેના નાના કદ માટે જાણીતું છે, જે તમારી ડોકર ઇમેજને પાતળી રાખવામાં મદદ કરે છે. તમારા પ્રોજેક્ટ માટે યોગ્ય અન્ય Node.js વર્ઝનનો વિચાર કરો.
• WORKDIR /app: કન્ટેનરની અંદર /app પર કાર્યકારી ડિરેક્ટરી સેટ કરે છે. આ તે છે જ્યાં તમારો એપ્લિકેશન કોડ રહેશે.
• COPY package*.json ./: package.json અને package-lock.json (અથવા જો તમે યાર્નનો ઉપયોગ કરો છો તો 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 નો ઉપયોગ કરશે.

ડોકર પછી તમારી ડોકરફાઇલમાંની સૂચનાઓનું પાલન કરશે, એક પછી એક સ્તર બનાવીને છબી બનાવશે. જ્યારે તમે પ્રથમ વખત છબી બનાવો છો, ત્યારે આધાર છબી ડાઉનલોડ કરવામાં અને નિર્ભરતા સ્થાપિત કરવામાં થોડો સમય લાગી શકે છે. જો કે, અનુગામી બિલ્ડ્સ ખૂબ ઝડપી હશે કારણ કે ડોકર મધ્યવર્તી સ્તરોને કેશ કરે છે.

ડોકર કન્ટેનર ચલાવો

છબી બનાવ્યા પછી, તમે નીચેના આદેશનો ઉપયોગ કરીને તેમાંથી કન્ટેનર ચલાવી શકો છો:

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": હોસ્ટ મશીન પરના પોર્ટ 3000 ને કન્ટેનરની અંદરના પોર્ટ 3000 પર મેપ કરે છે, જે docker run આદેશ જેવું જ છે.
• volumes: - .:/app: એક વોલ્યુમ બનાવે છે જે તમારા હોસ્ટ મશીન પરની વર્તમાન ડિરેક્ટરીને કન્ટેનરની અંદરની /app ડિરેક્ટરી પર માઉન્ટ કરે છે. આ તમને હોસ્ટ મશીન પર તમારા કોડમાં ફેરફાર કરવાની અને તેને કન્ટેનરની અંદર આપમેળે પ્રતિબિંબિત કરવાની મંજૂરી આપે છે, જે હોટ રીલોડિંગને સક્ષમ કરે છે.
• environment: NODE_ENV: development: કન્ટેનરની અંદર NODE_ENV એન્વાયર્નમેન્ટ વેરીએબલને development પર સેટ કરે છે. આ તમારી એપ્લિકેશનને ડેવલપમેન્ટ મોડમાં ચલાવવા માટે ગોઠવવા માટે ઉપયોગી છે.
• command: npm run dev: ડોકરફાઇલમાં વ્યાખ્યાયિત ડિફોલ્ટ આદેશને ઓવરરાઇડ કરે છે. આ કિસ્સામાં, અમે npm run dev નો ઉપયોગ કરી રહ્યાં છીએ, જેનો ઉપયોગ ઘણીવાર હોટ રીલોડિંગ સાથે ડેવલપમેન્ટ સર્વર શરૂ કરવા માટે થાય છે.

ડોકર કમ્પોઝનો ઉપયોગ કરીને એપ્લિકેશન શરૂ કરવા માટે, docker-compose.yml ફાઇલ ધરાવતી ડિરેક્ટરી પર નેવિગેટ કરો અને નીચેનો આદેશ ચલાવો:

docker-compose up

ડોકર કમ્પોઝ છબી બનાવશે (જો જરૂરી હોય તો) અને કન્ટેનર શરૂ કરશે. ડિટેચ્ડ મોડમાં (પૃષ્ઠભૂમિમાં) કન્ટેનર ચલાવવા માટે -d ફ્લેગ ઉમેરી શકાય છે.

અદ્યતન રૂપરેખાંકન વિકલ્પો

તમારા ડોકરાઇઝ્ડ જાવાસ્ક્રિપ્ટ ડેવલપમેન્ટ એન્વાયર્નમેન્ટને વધારવા માટે અહીં કેટલાક અદ્યતન રૂપરેખાંકન વિકલ્પો છે:

1. મલ્ટી-સ્ટેજ બિલ્ડ્સ

મલ્ટી-સ્ટેજ બિલ્ડ્સ તમને તમારા Dockerfile માં બહુવિધ FROM સૂચનાઓનો ઉપયોગ કરવાની મંજૂરી આપે છે, દરેક એક અલગ બિલ્ડ સ્ટેજનું પ્રતિનિધિત્વ કરે છે. આ તમારા અંતિમ છબીના કદને બિલ્ડ એન્વાયર્નમેન્ટને રનટાઇમ એન્વાયર્નમેન્ટથી અલગ કરીને ઘટાડવા માટે ઉપયોગી છે.

# સ્ટેજ 1: એપ્લિકેશન બનાવો
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY .\t.
RUN npm run build

# સ્ટેજ 2: રનટાઇમ છબી બનાવો
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. વીએસ કોડ સાથે ડિબગીંગ

વીએસ કોડ ડોકર કન્ટેનરમાં ચાલતી Node.js એપ્લિકેશન્સને ડિબગ કરવા માટે ઉત્તમ સપોર્ટ ધરાવે છે. તમે ચાલતા કન્ટેનર સાથે જોડવા અને બ્રેકપોઇન્ટ સેટ કરવા, ચલોનું નિરીક્ષણ કરવા અને તમારા કોડમાં સ્ટેપ કરવા માટે વીએસ કોડ ડોકર એક્સ્ટેંશનનો ઉપયોગ કરી શકો છો.

સૌ પ્રથમ, વીએસ કોડમાં ડોકર એક્સ્ટેંશન ઇન્સ્ટોલ કરો. પછી, નીચેના રૂપરેખાંકન સાથે તમારી .vscode ડિરેક્ટરીમાં launch.json ફાઇલ બનાવો:

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "node",
      "request": "attach",
      "name": "ડોકર સાથે જોડો",
      "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

પછી, વીએસ કોડમાં, "ડોકર સાથે જોડો" રૂપરેખાંકન પસંદ કરો અને ડિબગીંગ શરૂ કરો. તમે બ્રેકપોઇન્ટ સેટ કરી શકશો અને કન્ટેનરની અંદર ચાલતા તમારા કોડને ડિબગ કરી શકશો.

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 .\t.
EXPOSE 3000
CMD ["npm", "start"]

.npmrc ફાઇલમાં તમારું પ્રમાણીકરણ ટોકન હોવું જોઈએ:

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

YOUR_NPM_TOKEN ને તમારા વાસ્તવિક npm ટોકનથી બદલવાનું યાદ રાખો. આ ટોકનને સુરક્ષિત રાખો અને તેને તમારી સાર્વજનિક રિપોઝિટરીમાં કમિટ કરશો નહીં.

6. છબીનું કદ ઓપ્ટિમાઇઝ કરવું

ઝડપી બિલ્ડ અને જમાવટના સમય માટે તમારી ડોકર છબીનું કદ નાનું રાખવું મહત્વપૂર્ણ છે. અહીં છબીનું કદ ઓપ્ટિમાઇઝ કરવા માટેની કેટલીક ટીપ્સ આપી છે:

• હળવા આધાર છબીનો ઉપયોગ કરો, જેમ કે node:alpine.
• બિલ્ડ એન્વાયર્નમેન્ટને રનટાઇમ એન્વાયર્નમેન્ટથી અલગ કરવા માટે મલ્ટી-સ્ટેજ બિલ્ડ્સનો ઉપયોગ કરો.
• છબીમાંથી બિનજરૂરી ફાઇલો અને ડિરેક્ટરીઓ દૂર કરો.
• બિલ્ડ સંદર્ભમાંથી ફાઇલો અને ડિરેક્ટરીઓને બાકાત રાખવા માટે .dockerignore ફાઇલનો ઉપયોગ કરો.
• સ્તરોની સંખ્યા ઘટાડવા માટે બહુવિધ RUN આદેશોને એક જ આદેશમાં જોડો.

ઉદાહરણ: રીએક્ટ એપ્લિકેશનને ડોકરાઇઝ કરવું

ચાલો આ ખ્યાલોને વ્યવહારિક ઉદાહરણ સાથે દર્શાવીએ: ક્રિએટ રીએક્ટ એપ્લિકેશન સાથે બનાવેલ રીએક્ટ એપ્લિકેશનને ડોકરાઇઝ કરવી.

સૌ પ્રથમ, ક્રિએટ રીએક્ટ એપ્લિકેશનનો ઉપયોગ કરીને નવી રીએક્ટ એપ્લિકેશન બનાવો:

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 .\t.
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 ને ઑપ્ટિમાઇઝ કરો.

નિષ્કર્ષ

ડોકર સુસંગત અને પુનઃઉત્પાદન કરી શકાય તેવા જાવાસ્ક્રિપ્ટ ડેવલપમેન્ટ એન્વાયર્નમેન્ટ બનાવવા માટે એક શક્તિશાળી અને બહુમુખી ઉકેલ પૂરો પાડે છે. ડોકરનો ઉપયોગ કરીને, તમે સુસંગતતા સમસ્યાઓને દૂર કરી શકો છો, જમાવટને સરળ બનાવી શકો છો અને ખાતરી કરી શકો છો કે તમારી ટીમમાં દરેક જણ સમાન એન્વાયર્નમેન્ટ સાથે કામ કરે છે.

આ માર્ગદર્શિકાએ ડોકરાઇઝ્ડ જાવાસ્ક્રિપ્ટ ડેવલપમેન્ટ એન્વાયર્નમેન્ટ સેટ કરવાના મૂળભૂત બાબતો તેમજ કેટલાક અદ્યતન રૂપરેખાંકન વિકલ્પોને આવરી લીધા છે. આ પગલાંઓનું પાલન કરીને, તમે તમારી જાવાસ્ક્રિપ્ટ પ્રોજેક્ટ્સ માટે તેમની જટિલતા અથવા તમારી ટીમનું કદ ધ્યાનમાં લીધા વિના, એક મજબૂત અને કાર્યક્ષમ વર્કફ્લો બનાવી શકો છો. ડોકરને સ્વીકારો અને તમારી જાવાસ્ક્રિપ્ટ ડેવલપમેન્ટ પ્રક્રિયાની સંપૂર્ણ સંભાવનાને અનલૉક કરો.

આગળના પગલાં:

• તમારી ચોક્કસ જરૂરિયાતોને અનુરૂપ પહેલાથી બનાવેલી છબીઓ માટે ડોકર હબનું અન્વેષણ કરો.
• મલ્ટી-કન્ટેનર એપ્લિકેશન્સના સંચાલન માટે ડોકર કમ્પોઝમાં વધુ ઊંડાણપૂર્વક ડૂબકી લગાવો.
• ઉત્પાદન એન્વાયર્નમેન્ટમાં ડોકર કન્ટેનરને ઓર્કેસ્ટ્રેટ કરવા માટે ડોકર સ્વોર્મ અને કુબર્નેટ્સ વિશે જાણો.

તમારી વર્કફ્લોમાં આ શ્રેષ્ઠ પ્રયાસોનો સમાવેશ કરીને, તમે તમારી જાવાસ્ક્રિપ્ટ એપ્લિકેશન્સ માટે વધુ કાર્યક્ષમ, વિશ્વસનીય અને માપી શકાય તેવું ડેવલપમેન્ટ એન્વાયર્નમેન્ટ બનાવી શકો છો, આજના સ્પર્ધાત્મક બજારમાં સફળતાની ખાતરી કરો છો.