JavaScript izstrādes vide: Docker konteinera konfigurācija

Mūsdienu straujajā programmatūras izstrādes vidē ir būtiski uzturēt konsekventu un reproducējamu izstrādes vidi. Atšķirīgas operētājsistēmas, dažādas programmatūras versijas un konfliktējošas atkarības var novest pie bēdīgi slavenā "uz manas mašīnas viss strādā" sindroma. Docker, vadošā konteinerizācijas platforma, piedāvā spēcīgu risinājumu šai problēmai, ļaujot izstrādātājiem iepakot savu lietojumprogrammu un tās atkarības vienā, izolētā vienībā.

Šis ceļvedis jūs soli pa solim vedīs cauri stabilas un konsekventas JavaScript izstrādes vides izveidei, izmantojot Docker konteinerus. Mēs aptversim visu, sākot no pamata iestatīšanas līdz sarežģītām konfigurācijām, nodrošinot vienmērīgu un efektīvu darbplūsmu jūsu JavaScript projektiem, neatkarīgi no jūsu komandas daudzveidīgajām operētājsistēmām.

Kāpēc izmantot Docker JavaScript izstrādei?

Pirms iedziļināmies detaļās, apskatīsim Docker izmantošanas priekšrocības jūsu JavaScript izstrādes videi:

• Konsekvence: Docker nodrošina, ka visi komandas locekļi strādā ar precīzi tādu pašu vidi, novēršot saderības problēmas un samazinot vides atšķirību radītu kļūdu iespējamību. Tas ir īpaši svarīgi ģeogrāfiski izkliedētām komandām.
• Izolācija: Konteineri nodrošina izolāciju no resursdatora sistēmas, novēršot konfliktus ar citiem projektiem un nodrošinot, ka jūsu atkarības netraucē viena otrai.
• Reproducējamība: Docker attēlus var viegli koplietot un ieviest, padarot vienkāršu izstrādes vides reproducēšanu uz dažādām mašīnām vai ražošanā. Tas ir īpaši noderīgi, uzņemot jaunus komandas locekļus vai ieviešot dažādos mākoņpakalpojumu sniedzējos.
• Pārnesamība: Docker konteineri var darboties uz jebkuras platformas, kas atbalsta Docker, ieskaitot Windows, macOS un Linux, ļaujot izstrādātājiem izmantot savu iecienītāko operētājsistēmu, neietekmējot projektu.
• Vienkāršota ieviešana: To pašu Docker attēlu, kas izmantots izstrādē, var izmantot testēšanai un ražošanai, racionalizējot ieviešanas procesu un samazinot kļūdu risku.

Priekšnosacījumi

Pirms sākat, pārliecinieties, ka jums ir instalēts sekojošais:

• Docker: Lejupielādējiet un instalējiet Docker Desktop savai operētājsistēmai no oficiālās Docker vietnes (docker.com). Docker Desktop ietver Docker Engine, Docker CLI, Docker Compose un citus būtiskus rīkus.
• Node.js un npm (pēc izvēles): Lai gan tie nav obligāti nepieciešami jūsu resursdatorā, jo tie atradīsies konteinerī, lokāli instalēti Node.js un npm var būt noderīgi uzdevumiem ārpus konteinera vai sākotnējās projekta struktūras iestatīšanai. Jūs varat tos lejupielādēt no nodejs.org.
• Koda redaktors: Izvēlieties savu iecienītāko koda redaktoru (piemēram, VS Code, Sublime Text, Atom). VS Code ir lieliski Docker paplašinājumi, kas var vienkāršot jūsu darbplūsmu.

Pamata Dockerfile konfigurācija

Jebkuras uz Docker balstītas vides pamats ir Dockerfile. Šis fails satur instrukcijas jūsu Docker attēla veidošanai. Izveidosim pamata Dockerfile Node.js lietojumprogrammai:

# Izmantot oficiālu Node.js izpildlaika vidi kā vecākattēlu
FROM node:18-alpine

# Iestatīt darba direktoriju konteinerī
WORKDIR /app

# Kopēt package.json un package-lock.json uz darba direktoriju
COPY package*.json ./

# Instalēt lietojumprogrammas atkarības
RUN npm install

# Kopēt lietojumprogrammas pirmkodu uz darba direktoriju
COPY . .

# Atklāt 3000. portu ārpasaulei (pielāgojiet, ja jūsu lietotne izmanto citu portu)
EXPOSE 3000

# Definēt komandu, kas jāizpilda, startējot konteineri
CMD ["npm", "start"]

Apskatīsim katru rindu detalizētāk:

• FROM node:18-alpine: Norāda bāzes attēlu konteinerim. Šajā gadījumā mēs izmantojam oficiālo Node.js 18 Alpine attēlu, kas ir viegla Linux distribūcija. Alpine ir pazīstams ar savu mazo izmēru, kas palīdz uzturēt jūsu Docker attēlu kompaktu. Apsveriet citas Node.js versijas, kas piemērotas jūsu projektam.
• WORKDIR /app: Iestata darba direktoriju konteinerī uz /app. Šeit atradīsies jūsu lietojumprogrammas kods.
• COPY package*.json ./: Kopē package.json un package-lock.json (vai yarn.lock, ja lietojat Yarn) failus uz darba direktoriju. Šo failu kopēšana vispirms ļauj Docker kešot npm install soli, ievērojami paātrinot būvēšanas laiku, kad maināt tikai lietojumprogrammas kodu.
• RUN npm install: Instalē lietojumprogrammas atkarības, kas definētas package.json.
• COPY . .: Kopē visus atlikušos failus un direktorijas no jūsu lokālā projekta direktorijas uz darba direktoriju konteinerī.
• EXPOSE 3000: Atklāj 3000. portu, padarot to pieejamu no resursdatora. Tas ir svarīgi, ja jūsu lietojumprogramma klausās šo portu. Pielāgojiet porta numuru, ja jūsu lietojumprogramma izmanto citu portu.
• CMD ["npm", "start"]: Norāda komandu, kas jāizpilda, kad konteineris startē. Šajā gadījumā mēs izmantojam npm start, kas ir bieži sastopama komanda Node.js lietojumprogrammu startēšanai. Pārliecinieties, ka šī komanda atbilst komandai, kas definēta jūsu package.json scripts sadaļā.

Docker attēla būvēšana

Kad esat izveidojis savu Dockerfile, varat izveidot Docker attēlu, izmantojot šādu komandu:

docker build -t my-node-app .

Kur:

• docker build: Docker komanda attēlu būvēšanai.
• -t my-node-app: Norāda attēla birku (nosaukumu). Izvēlieties aprakstošu nosaukumu savai lietojumprogrammai.
• .: Norāda būvēšanas kontekstu, kas ir pašreizējā direktorija. Docker izmantos Dockerfile šajā direktorijā, lai izveidotu attēlu.

Docker pēc tam izpildīs instrukcijas jūsu Dockerfile, veidojot attēlu slāni pa slānim. Pirmo reizi veidojot attēlu, var paiet kāds laiks, lai lejupielādētu bāzes attēlu un instalētu atkarības. Tomēr nākamie būvējumi būs daudz ātrāki, jo Docker kešo starpposma slāņus.

Docker konteinera palaišana

Pēc attēla izveides varat palaist konteineri no tā, izmantojot šādu komandu:

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

Kur:

• docker run: Docker komanda konteineru palaišanai.
• -p 3000:3000: Piesaista 3000. portu resursdatorā 3000. portam konteinerī. Tas ļauj piekļūt jūsu lietojumprogrammai no pārlūkprogrammas, izmantojot localhost:3000. Pirmais numurs ir resursdatora ports, un otrais numurs ir konteinera ports.
• my-node-app: Attēla nosaukums, kuru vēlaties palaist.

Jūsu lietojumprogrammai tagad vajadzētu darboties Docker konteinerī. Jūs varat tai piekļūt, atverot pārlūkprogrammu un dodoties uz localhost:3000 (vai jūsu norādīto portu). Jums vajadzētu redzēt savas lietojumprogrammas sākuma ekrānu vai sākotnējo lietotāja saskarni.

Docker Compose izmantošana

Sarežģītākām lietojumprogrammām ar vairākiem pakalpojumiem Docker Compose ir nenovērtējams rīks. Tas ļauj definēt un pārvaldīt vairāku konteineru lietojumprogrammas, izmantojot YAML failu. Izveidosim docker-compose.yml failu mūsu Node.js lietojumprogrammai:

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

Apskatīsim katru sadaļu:

• version: "3.9": Norāda Docker Compose faila formāta versiju.
• services: Definē pakalpojumus, kas veido jūsu lietojumprogrammu. Šajā gadījumā mums ir viens pakalpojums ar nosaukumu app.
• build: .: Norāda, ka attēls jāveido no Dockerfile pašreizējā direktorijā.
• ports: - "3000:3000": Piesaista 3000. portu resursdatorā 3000. portam konteinerī, līdzīgi kā docker run komandā.
• volumes: - .:/app: Izveido sējumu, kas montē pašreizējo direktoriju jūsu resursdatorā uz /app direktoriju konteinerī. Tas ļauj veikt izmaiņas kodā resursdatorā un tās automātiski atspoguļojas konteinerī, nodrošinot karsto pārlādi (hot reloading).
• environment: NODE_ENV: development: Iestata NODE_ENV vides mainīgo konteinerī uz development. Tas ir noderīgi, lai konfigurētu lietojumprogrammu darbam izstrādes režīmā.
• command: npm run dev: Pārraksta noklusējuma komandu, kas definēta Dockerfile. Šajā gadījumā mēs izmantojam npm run dev, ko bieži izmanto, lai startētu izstrādes serveri ar karsto pārlādi.

Lai startētu lietojumprogrammu, izmantojot Docker Compose, dodieties uz direktoriju, kurā atrodas docker-compose.yml fails, un palaidiet šādu komandu:

docker-compose up

Docker Compose izveidos attēlu (ja nepieciešams) un startēs konteineri. Var pievienot -d karogu, lai palaistu konteineri atdalītā režīmā (fonā).

Papildu konfigurācijas iespējas

Šeit ir dažas papildu konfigurācijas iespējas, lai uzlabotu jūsu dokerizēto JavaScript izstrādes vidi:

1. Vairākpakāpju būvējumi

Vairākpakāpju būvējumi ļauj izmantot vairākas FROM instrukcijas jūsu Dockerfile, katra no tām pārstāvot atšķirīgu būvēšanas posmu. Tas ir noderīgi, lai samazinātu galīgā attēla izmēru, atdalot būvēšanas vidi no izpildlaika vides.

# 1. posms: Lietojumprogrammas būvēšana
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# 2. posms: Izpildlaika attēla izveide
FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Šajā piemērā pirmais posms (builder) būvē lietojumprogrammu, izmantojot Node.js. Otrais posms izmanto Nginx, lai pasniegtu izveidotos lietojumprogrammas failus. Tikai izveidotie faili no pirmā posma tiek kopēti uz otro posmu, tādējādi iegūstot mazāku un efektīvāku attēlu.

2. Vides mainīgo izmantošana

Vides mainīgie ir spēcīgs veids, kā konfigurēt lietojumprogrammu, nemainot kodu. Jūs varat definēt vides mainīgos savā docker-compose.yml failā vai nodot tos izpildlaikā, izmantojot -e karogu.

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

Savā lietojumprogrammā varat piekļūt šiem vides mainīgajiem, izmantojot process.env.

const apiUrl = process.env.API_URL;

3. Sējumu montēšana izstrādei

Sējumu montēšana (kā parādīts Docker Compose piemērā) ir būtiska izstrādei, jo tā ļauj veikt izmaiņas kodā resursdatorā un tās nekavējoties atspoguļojas konteinerī. Tas novērš nepieciešamību katru reizi pārveidot attēlu, kad veicat izmaiņas.

4. Atkļūdošana ar VS Code

VS Code ir lielisks atbalsts Node.js lietojumprogrammu atkļūdošanai, kas darbojas Docker konteineros. Jūs varat izmantot VS Code Docker paplašinājumu, lai pievienotos darbojošam konteinerim un iestatītu pārtraukuma punktus, pārbaudītu mainīgos un izietu cauri kodam soli pa solim.

Vispirms instalējiet Docker paplašinājumu VS Code. Pēc tam izveidojiet launch.json failu savā .vscode direktorijā ar šādu konfigurāciju:

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

Pārliecinieties, ka jūsu Node.js lietojumprogramma ir startēta ar --inspect vai --inspect-brk karogu. Piemēram, varat modificēt savu docker-compose.yml failu, lai iekļautu šo karogu:

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

Pēc tam VS Code atlasiet "Pievienoties Docker" konfigurāciju un sāciet atkļūdošanu. Jūs varēsiet iestatīt pārtraukuma punktus un atkļūdot savu kodu, kas darbojas konteinerī.

5. Privāta npm reģistra izmantošana

Ja strādājat pie projekta ar privātām npm pakotnēm, jums būs jākonfigurē Docker konteineris, lai autentificētos ar jūsu privāto npm reģistru. To var izdarīt, iestatot NPM_TOKEN vides mainīgo savā docker-compose.yml failā vai izveidojot .npmrc failu savā projekta direktorijā un kopējot to uz konteineri.

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

.npmrc failam jāsatur jūsu autentifikācijas marķieris:

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

Atcerieties aizstāt YOUR_NPM_TOKEN ar savu faktisko npm marķieri. Glabājiet šo marķieri drošībā un nepievienojiet to savai publiskajai repozitorijai.

6. Attēla izmēra optimizēšana

Maza Docker attēla izmēra uzturēšana ir svarīga ātrākai būvēšanas un ieviešanas laikam. Šeit ir daži padomi attēla izmēra optimizēšanai:

• Izmantojiet vieglu bāzes attēlu, piemēram, node:alpine.
• Izmantojiet vairākpakāpju būvējumus, lai atdalītu būvēšanas vidi no izpildlaika vides.
• Noņemiet nevajadzīgos failus un direktorijas no attēla.
• Izmantojiet .dockerignore failu, lai izslēgtu failus un direktorijas no būvēšanas konteksta.
• Apvienojiet vairākas RUN komandas vienā komandā, lai samazinātu slāņu skaitu.

Piemērs: React lietojumprogrammas dokerizācija

Ilustrēsim šos jēdzienus ar praktisku piemēru: React lietojumprogrammas dokerizācija, kas izveidota ar Create React App.

Vispirms izveidojiet jaunu React lietojumprogrammu, izmantojot Create React App:

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

Pēc tam izveidojiet Dockerfile projekta saknes direktorijā:

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

Izveidojiet docker-compose.yml failu:

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

Piezīme: Mēs piesaistām 3000. portu resursdatorā 80. portam konteinerī, jo Nginx pasniedz lietojumprogrammu uz 80. porta. Jums var nākties pielāgot portu piesaisti atkarībā no jūsu lietojumprogrammas konfigurācijas.

Visbeidzot, palaidiet docker-compose up, lai izveidotu un startētu lietojumprogrammu. Pēc tam varat piekļūt lietojumprogrammai, pārlūkprogrammā dodoties uz localhost:3000.

Biežākās problēmas un to risināšana

Pat ar rūpīgu konfigurāciju, strādājot ar Docker, jūs varat saskarties ar problēmām. Šeit ir dažas biežākās problēmas un to risinājumi:

• Portu konflikti: Pārliecinieties, ka porti, kurus jūs piesaistāt savā docker-compose.yml vai docker run komandā, jau nav aizņemti citām lietojumprogrammām jūsu resursdatorā.
• Sējumu montēšanas problēmas: Pārbaudiet atļaujas failiem un direktorijām, kuras montējat. Docker var nebūt nepieciešamo atļauju, lai piekļūtu failiem.
• Attēla būvēšanas kļūmes: Rūpīgi pārbaudiet docker build komandas izvadi, meklējot kļūdas. Bieži cēloņi ir nepareiza Dockerfile sintakse, trūkstošas atkarības vai tīkla problēmas.
• Konteinera avārijas: Izmantojiet docker logs komandu, lai apskatītu sava konteinera žurnālus un identificētu avārijas cēloni. Bieži cēloņi ir lietojumprogrammas kļūdas, trūkstoši vides mainīgie vai resursu ierobežojumi.
• Lēns būvēšanas laiks: Optimizējiet savu Dockerfile, izmantojot vairākpakāpju būvējumus, kešojot atkarības un samazinot slāņu skaitu.

Noslēgums

Docker nodrošina spēcīgu un daudzpusīgu risinājumu konsekventu un reproducējamu JavaScript izstrādes vidi izveidei. Izmantojot Docker, jūs varat novērst saderības problēmas, vienkāršot ieviešanu un nodrošināt, ka visi komandas locekļi strādā ar vienādu vidi.

Šis ceļvedis ir aptvēris pamatus dokerizētas JavaScript izstrādes vides iestatīšanai, kā arī dažas papildu konfigurācijas iespējas. Sekojot šiem soļiem, jūs varat izveidot stabilu un efektīvu darbplūsmu saviem JavaScript projektiem neatkarīgi no to sarežģītības vai jūsu komandas lieluma. Pieņemiet Docker un atraisiet pilnu sava JavaScript izstrādes procesa potenciālu.

Nākamie soļi:

• Izpētiet Docker Hub, lai atrastu iepriekš sagatavotus attēlus, kas atbilst jūsu īpašajām vajadzībām.
• Iedziļinieties Docker Compose, lai pārvaldītu vairāku konteineru lietojumprogrammas.
• Uzziniet par Docker Swarm un Kubernetes, lai orķestrētu Docker konteinerus ražošanas vidēs.

Iekļaujot šīs labākās prakses savā darbplūsmā, jūs varat izveidot efektīvāku, uzticamāku un mērogojamāku izstrādes vidi savām JavaScript lietojumprogrammām, nodrošinot panākumus mūsdienu konkurences tirgū.