JavaScript'i arenduskeskkond: Dockeri konteineri seadistamine

Tänapäeva kiires tarkvaraarenduse maastikul on järjepideva ja korratava arenduskeskkonna säilitamine ülioluline. Erinevad operatsioonisüsteemid, varieeruvad tarkvaraversioonid ja vastuolulised sõltuvused võivad viia kardetud "minu masinas see töötab" sündroomini. Docker, juhtiv konteineriseerimisplatvorm, pakub sellele probleemile võimsa lahenduse, võimaldades arendajatel pakendada oma rakenduse ja selle sõltuvused ühte, isoleeritud üksusesse.

See juhend juhatab teid läbi stabiilse ja järjepideva JavaScripti arenduskeskkonna seadistamise protsessi Dockeri konteinerite abil. Me katame kõik alates põhiseadistusest kuni täiustatud konfiguratsioonideni, tagades teie JavaScripti projektidele sujuva ja tõhusa töövoo, olenemata teie meeskonna erinevatest operatsioonisüsteemidest.

Miks kasutada Dockerit JavaScripti arenduseks?

Enne üksikasjadesse süvenemist uurime Dockeri kasutamise eeliseid teie JavaScripti arenduskeskkonnas:

• Järjepidevus: Docker tagab, et kõik teie meeskonnas töötavad täpselt samasuguses keskkonnas, elimineerides ühilduvusprobleemid ja vähendades keskkonnaerinevustest tingitud vigade tõenäosust. See on eriti oluline geograafiliselt hajutatud meeskondade puhul.
• Isolatsioon: Konteinerid pakuvad isolatsiooni host-süsteemist, vältides konflikte teiste projektidega ja tagades, et teie sõltuvused ei sega üksteist.
• Korratavus: Dockeri tõmmiseid saab hõlpsasti jagada ja juurutada, mis teeb arenduskeskkonna taastootmise erinevates masinates või tootmises lihtsaks. See on eriti kasulik uute meeskonnaliikmete sisseelamisel või erinevatele pilveteenuse pakkujatele juurutamisel.
• Kaasaskantavus: Dockeri konteinerid võivad töötada mis tahes platvormil, mis toetab Dockerit, sealhulgas Windows, macOS ja Linux, võimaldades arendajatel kasutada oma eelistatud operatsioonisüsteemi projekti mõjutamata.
• Lihtsustatud juurutamine: Sama Dockeri tõmmist, mida kasutati arenduseks, saab kasutada ka testimiseks ja tootmiseks, mis muudab juurutamisprotsessi sujuvamaks ja vähendab vigade riski.

Eeltingimused

Enne alustamist veenduge, et teil on installitud järgmised vahendid:

• Docker: Laadige alla ja installige Docker Desktop oma operatsioonisüsteemile ametlikult Dockeri veebisaidilt (docker.com). Docker Desktop sisaldab Docker Engine'it, Docker CLI-d, Docker Compose'i ja teisi olulisi tööriistu.
• Node.js ja npm (valikuline): Kuigi need pole teie host-masinas rangelt nõutavad, kuna need asuvad konteineris, võib Node.js-i ja npm-i lokaalne olemasolu olla abiks konteineriväliste ülesannete või esialgse projekti struktuuri seadistamisel. Saate need alla laadida saidilt nodejs.org.
• Koodiredaktor: Valige oma eelistatud koodiredaktor (nt VS Code, Sublime Text, Atom). VS Code'il on suurepärased Dockeri laiendused, mis võivad teie töövoogu lihtsustada.

Dockerfile'i põhikonfiguratsioon

Iga Dockeril põhineva keskkonna aluseks on Dockerfile. See fail sisaldab juhiseid teie Dockeri tõmmise ehitamiseks. Loome põhilisema Dockerfile'i Node.js rakenduse jaoks:

# 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"]

Vaatame iga rea lahti:

• FROM node:18-alpine: Määrab konteineri baastõmmise. Sel juhul kasutame ametlikku Node.js 18 Alpine tõmmist, mis on kergekaaluline Linuxi distributsioon. Alpine on tuntud oma väikese suuruse poolest, mis aitab hoida teie Dockeri tõmmise saledana. Kaaluge vastavalt oma projektile ka teisi Node.js versioone.
• WORKDIR /app: Määrab töökataloogi konteineri sees asukohta /app. See on koht, kus teie rakenduse kood asub.
• COPY package*.json ./: Kopeerib package.json ja package-lock.json (või yarn.lock, kui kasutate Yarn'i) failid töökataloogi. Nende failide esimesena kopeerimine võimaldab Dockeril vahemällu salvestada npm install sammu, mis kiirendab oluliselt ehitusaega, kui muudate ainult rakenduse koodi.
• RUN npm install: Installib rakenduse sõltuvused, mis on defineeritud package.json failis.
• COPY . .: Kopeerib kõik ülejäänud failid ja kataloogid teie lokaalsest projektikataloogist konteineri sees asuvasse töökataloogi.
• EXPOSE 3000: Avab pordi 3000 välismaailmale, muutes selle host-masinast kättesaadavaks. See on oluline, kui teie rakendus kuulab sellel pordil. Muutke pordi numbrit, kui teie rakendus kasutab teist porti.
• CMD ["npm", "start"]: Määrab käsu, mis käivitatakse konteineri käivitamisel. Sel juhul kasutame npm start, mis on tavaline käsk Node.js rakenduste käivitamiseks. Veenduge, et see käsk vastaks käsule, mis on defineeritud teie package.json faili scripts jaotises.

Dockeri tõmmise ehitamine

Kui olete oma Dockerfile'i loonud, saate Dockeri tõmmise ehitada järgmise käsuga:

docker build -t my-node-app .

Kus:

• docker build: Dockeri käsk tõmmiste ehitamiseks.
• -t my-node-app: Määrab tõmmise sildi (nime). Valige oma rakendusele kirjeldav nimi.
• .: Määrab ehituskonteksti, mis on praegune kataloog. Docker kasutab tõmmise ehitamiseks selles kataloogis asuvat Dockerfile'i.

Docker täidab seejärel teie Dockerfile'is olevad juhised, ehitades tõmmise kiht-kihilt. Esimest korda tõmmist ehitades võib baastõmmise allalaadimine ja sõltuvuste installimine aega võtta. Kuid järgnevad ehitused on palju kiiremad, kuna Docker salvestab vahepealsed kihid vahemällu.

Dockeri konteineri käivitamine

Pärast tõmmise ehitamist saate sellest konteineri käivitada järgmise käsuga:

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

Kus:

• docker run: Dockeri käsk konteinerite käivitamiseks.
• -p 3000:3000: Seob host-masina pordi 3000 konteineri sees oleva pordiga 3000. See võimaldab teil oma rakendusele brauserist ligi pääseda, kasutades localhost:3000. Esimene number on hosti port ja teine number on konteineri port.
• my-node-app: Tõmmise nimi, mida soovite käivitada.

Teie rakendus peaks nüüd töötama Dockeri konteineri sees. Saate sellele ligi pääseda, avades oma brauseri ja navigeerides aadressile localhost:3000 (või teie määratud pordile). Peaksite nägema oma rakenduse tervituskuva või esialgset kasutajaliidest.

Docker Compose'i kasutamine

Keerulisemate, mitme teenusega rakenduste jaoks on Docker Compose hindamatu tööriist. See võimaldab teil defineerida ja hallata mitme konteineriga rakendusi YAML-faili abil. Loome oma Node.js rakenduse jaoks docker-compose.yml faili:

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

Uurime iga jaotist:

• version: "3.9": Määrab Docker Compose'i failivormingu versiooni.
• services: Defineerib teenused, mis moodustavad teie rakenduse. Sel juhul on meil üks teenus nimega app.
• build: .: Määrab, et tõmmis tuleks ehitada praeguses kataloogis asuvast Dockerfile'ist.
• ports: - "3000:3000": Seob host-masina pordi 3000 konteineri sees oleva pordiga 3000, sarnaselt docker run käsuga.
• volumes: - .:/app: Loob köite (volume), mis ühendab teie host-masina praeguse kataloogi konteineri sees asuva /app kataloogiga. See võimaldab teil teha muudatusi oma koodis host-masinal ja näha neid automaatselt kajastumas konteineri sees, võimaldades "hot reloading'ut".
• environment: NODE_ENV: development: Määrab konteineri sees keskkonnamuutuja NODE_ENV väärtuseks development. See on kasulik rakenduse seadistamiseks arendusrežiimis töötamiseks.
• command: npm run dev: Tühistab Dockerfile'is määratletud vaikekäsu. Sel juhul kasutame npm run dev, mida kasutatakse sageli arendusserveri käivitamiseks koos "hot reloading'uga".

Rakenduse käivitamiseks Docker Compose'i abil navigeerige kataloogi, mis sisaldab docker-compose.yml faili, ja käivitage järgmine käsk:

docker-compose up

Docker Compose ehitab tõmmise (vajadusel) ja käivitab konteineri. Lipu -d saab lisada, et käivitada konteiner eraldatud režiimis (taustal).

Täiustatud seadistusvalikud

Siin on mõned täiustatud seadistusvalikud, et täiustada teie Dockeriseeritud JavaScripti arenduskeskkonda:

1. Mitmeastmelised ehitused (Multi-Stage Builds)

Mitmeastmelised ehitused võimaldavad teil kasutada oma Dockerfile'is mitut FROM juhist, millest igaüks esindab erinevat ehitusetappi. See on kasulik lõpliku tõmmise suuruse vähendamiseks, eraldades ehituskeskkonna käituskeskkonnast.

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

# 2. etapp: Käitustõmmise loomine
FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Selles näites ehitab esimene etapp (builder) rakenduse Node.js abil. Teine etapp kasutab Nginxit ehitatud rakenduse failide serveerimiseks. Ainult esimesest etapist pärit ehitatud failid kopeeritakse teise etappi, mille tulemuseks on väiksem ja tõhusam tõmmis.

2. Keskkonnamuutujate kasutamine

Keskkonnamuutujad on võimas viis rakenduse seadistamiseks ilma koodi muutmata. Saate defineerida keskkonnamuutujaid oma docker-compose.yml failis või edastada need käivitamisel, kasutades -e lippu.

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

Oma rakenduse sees saate neile keskkonnamuutujatele ligi pääseda, kasutades process.env.

const apiUrl = process.env.API_URL;

3. Köidete ühendamine (Volume Mounting) arenduseks

Köidete ühendamine (nagu näidatud Docker Compose'i näites) on arenduseks ülioluline, kuna see võimaldab teil teha muudatusi oma koodis host-masinal ja näha neid koheselt kajastumas konteineri sees. See välistab vajaduse tõmmist iga kord uuesti ehitada, kui teete muudatuse.

4. Silumine VS Code'iga

VS Code'il on suurepärane tugi Dockeri konteinerites töötavate Node.js rakenduste silumiseks. Saate kasutada VS Code'i Dockeri laiendust, et ühenduda töötava konteineriga ja seada murdepunkte, inspekteerida muutujaid ja samm-sammult koodi läbida.

Esmalt installige VS Code'is Dockeri laiendus. Seejärel looge oma .vscode kataloogi fail launch.json järgmise konfiguratsiooniga:

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

Veenduge, et teie Node.js rakendus on käivitatud lipuga --inspect või --inspect-brk. Näiteks saate muuta oma docker-compose.yml faili, et lisada see lipp:

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

Seejärel valige VS Code'is "Attach to Docker" konfiguratsioon ja alustage silumist. Saate seada murdepunkte ja siluda oma koodi, mis töötab konteineri sees.

5. Privaatse npm-registri kasutamine

Kui töötate projektiga, mis kasutab privaatseid npm-pakette, peate oma Dockeri konteineri seadistama autentimiseks teie privaatse npm-registriga. Seda saab teha, seadistades keskkonnamuutuja NPM_TOKEN oma docker-compose.yml failis või luues oma projektikataloogi .npmrc faili ja kopeerides selle konteinerisse.

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

.npmrc fail peaks sisaldama teie autentimistõendit:

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

Ärge unustage asendada YOUR_NPM_TOKEN oma tegeliku npm-tõendiga. Hoidke seda tõendit turvaliselt ja ärge lisage seda oma avalikku repositooriumi.

6. Tõmmise suuruse optimeerimine

Dockeri tõmmise suuruse väiksena hoidmine on oluline kiiremate ehitus- ja juurutamisaegade jaoks. Siin on mõned näpunäited tõmmise suuruse optimeerimiseks:

• Kasutage kergekaalulist baastõmmist, näiteks node:alpine.
• Kasutage mitmeastmelisi ehitusi, et eraldada ehituskeskkond käituskeskkonnast.
• Eemaldage tõmmisest mittevajalikud failid ja kataloogid.
• Kasutage .dockerignore faili, et välistada faile ja katalooge ehituskontekstist.
• Ühendage mitu RUN käsku üheks käsuks, et vähendada kihtide arvu.

Näide: Reacti rakenduse Dockeriseerimine

Illustreerime neid kontseptsioone praktilise näitega: Reacti rakenduse Dockeriseerimine, mis on loodud Create React App'iga.

Esmalt looge uus Reacti rakendus, kasutades Create React App'i:

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

Seejärel looge projekti juurkataloogi 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;"]

Looge docker-compose.yml fail:

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

Märkus: me seome hosti pordi 3000 konteineri sees oleva pordiga 80, kuna Nginx serveerib rakendust pordil 80. Võimalik, et peate pordi sidumist kohandama vastavalt oma rakenduse konfiguratsioonile.

Lõpuks käivitage docker-compose up, et rakendus ehitada ja käivitada. Seejärel pääsete rakendusele ligi, navigeerides oma brauseris aadressile localhost:3000.

Levinud probleemid ja tõrkeotsing

Isegi hoolika seadistamise korral võite Dockeriga töötades kokku puutuda probleemidega. Siin on mõned levinud probleemid ja nende lahendused:

• Pordikonfliktid: Veenduge, et pordid, mida te oma docker-compose.yml või docker run käsus seote, ei oleks teie host-masinas juba teiste rakenduste poolt kasutusel.
• Köite ühendamise probleemid: Kontrollige ühendatavate failide ja kataloogide õigusi. Dockeril ei pruugi olla failidele juurdepääsuks vajalikke õigusi.
• Tõmmise ehitamise tõrked: Uurige hoolikalt docker build käsu väljundit vigade leidmiseks. Levinud põhjused on vale Dockerfile'i süntaks, puuduvad sõltuvused või võrguprobleemid.
• Konteineri kokkujooksmised: Kasutage docker logs käsku, et vaadata oma konteineri logisid ja tuvastada kokkujooksmise põhjus. Levinud põhjused on rakenduse vead, puuduvad keskkonnamuutujad või ressursipiirangud.
• Aeglased ehitusajad: Optimeerige oma Dockerfile'i, kasutades mitmeastmelisi ehitusi, sõltuvuste vahemällu salvestamist ja kihtide arvu minimeerimist.

Kokkuvõte

Docker pakub võimsat ja mitmekülgset lahendust järjepidevate ja korratavate JavaScripti arenduskeskkondade loomiseks. Dockerit kasutades saate elimineerida ühilduvusprobleemid, lihtsustada juurutamist ja tagada, et kõik teie meeskonnas töötavad samas keskkonnas.

See juhend on käsitlenud Dockeriseeritud JavaScripti arenduskeskkonna seadistamise põhitõdesid ning mõningaid täiustatud seadistusvalikuid. Neid samme järgides saate luua oma JavaScripti projektidele stabiilse ja tõhusa töövoo, olenemata nende keerukusest või teie meeskonna suurusest. Võtke Docker omaks ja avage oma JavaScripti arendusprotsessi täielik potentsiaal.

Järgmised sammud:

• Uurige Docker Hubi, et leida eelnevalt ehitatud tõmmiseid, mis vastavad teie spetsiifilistele vajadustele.
• Süvenege Docker Compose'i, et hallata mitme konteineriga rakendusi.
• Õppige tundma Docker Swarmi ja Kubernetes't Dockeri konteinerite orkestreerimiseks tootmiskeskkondades.

Lisades need parimad praktikad oma töövoogu, saate luua oma JavaScripti rakendustele tõhusama, usaldusväärsema ja skaleeritavama arenduskeskkonna, tagades edu tänapäeva konkurentsitihedal turul.