TypeScript ir Docker Integracija: Konteinerių Tipo Saugumas Patikimoms Programoms

Šiuolaikiniame programinės įrangos kūrime konteinerizacija naudojant Docker tapo standartine praktika. Sujungus su TypeScript teikiamu tipo saugumu, kūrėjai gali kurti patikimesnes ir lengviau prižiūrimas programas. Šiame išsamiame vadove nagrinėjama, kaip efektyviai integruoti TypeScript su Docker, užtikrinant konteinerių tipo saugumą visą kūrimo ciklą.

Kodėl TypeScript ir Docker?

TypeScript į JavaScript įveda statinį tipavimą, leidžiantį kūrėjams anksti aptikti klaidas kūrimo procese. Tai sumažina klaidų skaičių vykdymo metu ir pagerina kodo kokybę. Docker suteikia nuoseklią ir izoliuotą aplinką programoms, užtikrinant, kad jos patikimai veiktų skirtingose aplinkose, nuo kūrimo iki gamybos.

Šių dviejų technologijų integravimas suteikia keletą pagrindinių privalumų:

• Patobulintas tipo saugumas: pagaukite su tipais susijusias klaidas kompiliavimo metu, o ne vykdymo metu konteineryje.
• Pagerinta kodo kokybė: TypeScript statinis tipavimas skatina geresnę kodo struktūrą ir prižiūrimumą.
• Nuoseklios aplinkos: Docker užtikrina, kad jūsų programa veiktų nuoseklioje aplinkoje, neatsižvelgiant į pagrindinę infrastruktūrą.
• Supaprastintas diegimas: Docker supaprastina diegimo procesą, todėl lengviau diegti programas įvairiose aplinkose.
• Padidėjęs produktyvumas: ankstyvas klaidų aptikimas ir nuoseklios aplinkos prisideda prie didesnio kūrėjų produktyvumo.

TypeScript projekto sąranka su Docker

Norėdami pradėti, jums reikės TypeScript projekto ir Docker įdiegto jūsų kompiuteryje. Štai žingsnis po žingsnio vadovas:

1. Projekto inicializavimas

Sukurkite naują katalogą savo projektui ir inicializuokite TypeScript projektą:

            mkdir typescript-docker
cd typescript-docker
npm init -y
npm install typescript --save-dev
tsc --init
            

              
                Copy
              
            
          

Tai sukurs `package.json` failą ir `tsconfig.json` failą, kuris konfigūruoja TypeScript kompiliatorių.

2. TypeScript konfigūravimas

Atidarykite `tsconfig.json` ir sukonfigūruokite kompiliatoriaus parinktis pagal savo projekto reikalavimus. Pagrindinė konfigūracija gali atrodyti taip:

            {
  "compilerOptions": {
    "target": "es6",
    "module": "commonjs",
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  }
}
            

              
                Copy
              
            
          

Štai pagrindinių parinkčių apžvalga:

• `target`: nurodo ECMAScript tikslinę versiją.
• `module`: nurodo modulio kodo generavimą.
• `outDir`: nurodo kompiliuotų JavaScript failų išvesties katalogą.
• `rootDir`: nurodo šaltinio failų šakninį katalogą.
• `strict`: įgalina visas griežto tipo tikrinimo parinktis.
• `esModuleInterop`: įgalina sąveiką tarp CommonJS ir ES modulių.

3. Šaltinio failų kūrimas

Sukurkite `src` katalogą ir pridėkite TypeScript šaltinio failus. Pavyzdžiui, sukurkite failą pavadinimu `src/index.ts` su šiuo turiniu:

            // src/index.ts
function greet(name: string): string {
  return `Hello, ${name}!`;
}

console.log(greet("World"));
            

              
                Copy
              
            
          

4. Dockerfile kūrimas

Sukurkite `Dockerfile` savo projekto šakniniame kataloge. Šis failas apibrėžia veiksmus, reikalingus Docker vaizdui sukurti.

            # 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 dependencies
RUN npm install

# Copy TypeScript source files
COPY src ./src

# Compile TypeScript code
RUN npm run tsc

# Expose the port your app runs on
EXPOSE 3000

# Command to run the application
CMD ["node", "dist/index.js"]
            

              
                Copy
              
            
          

Išanalizuokime `Dockerfile`:

• `FROM node:18-alpine`: naudoja oficialų Node.js Alpine Linux vaizdą kaip pagrindinį vaizdą. Alpine Linux yra lengvas platinimas, todėl vaizdo dydžiai yra mažesni.
• `WORKDIR /app`: nustato darbinį katalogą konteinerio viduje į `/app`.
• `COPY package*.json ./`: kopijuoja `package.json` ir `package-lock.json` failus į darbinį katalogą.
• `RUN npm install`: įdiegia projekto priklausomybes naudojant `npm`.
• `COPY src ./src`: kopijuoja TypeScript šaltinio failus į darbinį katalogą.
• `RUN npm run tsc`: kompiliuoja TypeScript kodą naudojant komandą `tsc` (turėsite apibrėžti šį scenarijų savo `package.json`).
• `EXPOSE 3000`: atveria 3000 prievadą, kad būtų galima išoriškai pasiekti programą.
• `CMD ["node", "dist/index.js"]`: nurodo komandą paleisti programą, kai konteineris paleidžiamas.

5. Kompiliavimo scenarijaus pridėjimas

Pridėkite `build` scenarijų į savo `package.json` failą, kad kompiliuotumėte TypeScript kodą:

            {
  "name": "typescript-docker",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "build": "tsc",
    "start": "node dist/index.js"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "devDependencies": {
    "typescript": "^4.0.0"
  },
  "dependencies": {}
}
            

              
                Copy
              
            
          

6. Docker vaizdo kūrimas

Sukurkite Docker vaizdą naudodami šią komandą:

            docker build -t typescript-docker .
            

              
                Copy
              
            
          

Ši komanda sukuria vaizdą naudodama `Dockerfile` esantį dabartiniame kataloge ir pažymi jį kaip `typescript-docker`. Taškas (`.`) nurodo kūrimo kontekstą, kuris yra dabartinis katalogas.

7. Docker konteinerio paleidimas

Paleiskite Docker konteinerį naudodami šią komandą:

            docker run -p 3000:3000 typescript-docker
            

              
                Copy
              
            
          

Ši komanda paleidžia `typescript-docker` vaizdą ir susieja 3000 prievadą pagrindiniame kompiuteryje su 3000 prievadu konteineryje. Terminale turėtumėte pamatyti "Hello, World!" išvestį.

Išplėstinė TypeScript ir Docker integracija

1. Docker Compose naudojimas

Docker Compose supaprastina kelių konteinerių programų valdymą. Galite apibrėžti savo programos paslaugas, tinklus ir tomus faile `docker-compose.yml`. Štai pavyzdys:

            version: "3.8"
services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "3000:3000"
    volumes:
      - ./src:/app/src
    environment:
      NODE_ENV: development
            

              
                Copy
              
            
          

Šis `docker-compose.yml` failas apibrėžia vieną paslaugą pavadinimu `app`. Jame nurodomas kūrimo kontekstas, Dockerfile, prievadų susiejimai, tomai ir aplinkos kintamieji.

Norėdami paleisti programą naudojant Docker Compose, paleiskite šią komandą:

            docker-compose up -d
            

              
                Copy
              
            
          

Vėliavėlė `-d` paleidžia programą atjungtu režimu, o tai reiškia, kad ji veiks fone.

Docker Compose yra ypač naudinga, kai jūsų programa susideda iš kelių paslaugų, tokių kaip priekinė sąsaja, galinė sąsaja ir duomenų bazė.

2. Kūrimo darbo eiga su karštu perkrovimu

Norėdami pagerinti kūrimo patirtį, galite sukonfigūruoti karštą perkrovimą, kuris automatiškai atnaujina programą, kai atliekate pakeitimus šaltinio kode. Tai galima pasiekti naudojant tokius įrankius kaip `nodemon` ir `ts-node`.

Pirmiausia įdiekite reikiamas priklausomybes:

            npm install nodemon ts-node --save-dev
            

              
                Copy
              
            
          

Tada atnaujinkite savo `package.json` failą naudodami `dev` scenarijų:

            {
  "name": "typescript-docker",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "build": "tsc",
    "start": "node dist/index.js",
    "dev": "nodemon --watch 'src/**/*.ts' --exec ts-node src/index.ts"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "devDependencies": {
    "typescript": "^4.0.0",
    "nodemon": "^2.0.0",
    "ts-node": "^9.0.0"
  },
  "dependencies": {}
}
            

              
                Copy
              
            
          

Pakeiskite `docker-compose.yml`, kad susietumėte šaltinio kodo katalogą su konteineriu

            version: "3.8"
services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "3000:3000"
    volumes:
      - ./src:/app/src
      - ./node_modules:/app/node_modules
    environment:
      NODE_ENV: development
            

              
                Copy
              
            
          

Atnaujinkite Dockerfile, kad neįtrauktumėte kompiliavimo žingsnio:

            # 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 dependencies
RUN npm install

# Copy TypeScript source files
COPY src ./src

# Expose the port your app runs on
EXPOSE 3000

# Command to run the application
CMD ["npm", "run", "dev"]
            

              
                Copy
              
            
          

Dabar paleiskite programą naudodami Docker Compose:

            docker-compose up -d
            

              
                Copy
              
            
          

Bet kokie pakeitimai, kuriuos atliksite TypeScript šaltinio failuose, automatiškai suaktyvins programos paleidimą iš naujo konteinerio viduje, suteikdami greitesnę ir efektyvesnę kūrimo patirtį.

3. Daugiapakopiai kūrimai

Daugiapakopiai kūrimai yra galinga technika, skirta optimizuoti Docker vaizdų dydžius. Jie leidžia naudoti kelis `FROM` nurodymus viename `Dockerfile`, kopijuojant artefaktus iš vienos pakopos į kitą.

Štai daugiapakopio `Dockerfile` pavyzdys TypeScript programai:

            # Stage 1: Build the application
FROM node:18-alpine as builder

WORKDIR /app

COPY package*.json ./

RUN npm install

COPY src ./src

RUN npm run build

# Stage 2: Create the final image
FROM node:18-alpine

WORKDIR /app

COPY package*.json ./

RUN npm install --production

COPY --from=builder /app/dist ./dist

EXPOSE 3000

CMD ["node", "dist/index.js"]
            

              
                Copy
              
            
          

Šiame pavyzdyje pirmoji pakopa (`builder`) kompiliuoja TypeScript kodą ir generuoja JavaScript failus. Antroji pakopa sukuria galutinį vaizdą, kopijuodama tik būtinus failus iš pirmosios pakopos. Tai lemia mažesnį vaizdo dydį, nes jame nėra kūrimo priklausomybių ar TypeScript šaltinio failų.

4. Aplinkos kintamųjų naudojimas

Aplinkos kintamieji yra patogus būdas konfigūruoti programą nekeičiant kodo. Galite apibrėžti aplinkos kintamuosius savo `docker-compose.yml` faile arba perduoti juos kaip komandų eilutės argumentus paleidžiant konteinerį.

Norėdami pasiekti aplinkos kintamuosius savo TypeScript kode, naudokite `process.env` objektą:

            // src/index.ts
const port = process.env.PORT || 3000;

console.log(`Server listening on port ${port}`);
            

              
                Copy
              
            
          

Savo `docker-compose.yml` faile apibrėžkite aplinkos kintamąjį:

            version: "3.8"
services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "3000:3000"
    environment:
      PORT: 3000
            

              
                Copy
              
            
          

5. Tomų prijungimas duomenų išsaugojimui

Tomų prijungimas leidžia dalytis duomenimis tarp pagrindinio kompiuterio ir konteinerio. Tai naudinga išsaugant duomenis, tokius kaip duomenų bazės arba įkelti failai, net kai konteineris sustabdomas arba pašalinamas.

Norėdami prijungti tomą, nurodykite parinktį `volumes` savo `docker-compose.yml` faile:

            version: "3.8"
services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "3000:3000"
    volumes:
      - ./data:/app/data
    environment:
      NODE_ENV: development
            

              
                Copy
              
            
          

Tai prijungs `./data` katalogą pagrindiniame kompiuteryje prie `/app/data` katalogo konteineryje. Bet kokie failai, sukurti `/app/data` kataloge, bus išsaugomi pagrindiniame kompiuteryje.

Konteinerių tipo saugumo užtikrinimas

Nors Docker suteikia nuoseklią aplinką, labai svarbu užtikrinti, kad jūsų TypeScript kodas būtų saugus pagal tipą konteineryje. Štai keletas geriausių praktikų:

1. Griežta TypeScript konfigūracija

Įgalinkite visas griežto tipo tikrinimo parinktis savo `tsconfig.json` faile. Tai padės jums anksti aptikti galimas su tipais susijusias klaidas kūrimo procese. Įsitikinkite, kad "strict": true yra jūsų tsconfig.json.

2. Lintinimas ir kodo formatavimas

Naudokite linterį ir kodo formatavimo priemonę, tokią kaip ESLint ir Prettier, kad įgyvendintumėte kodavimo standartus ir aptiktumėte galimas klaidas. Integruokite šiuos įrankius į savo kompiliavimo procesą, kad automatiškai patikrintumėte, ar jūsų kode nėra klaidų ir neatitikimų.

3. Vienetų testavimas

Parašykite vienetų testus, kad patikrintumėte savo kodo funkcionalumą. Vienetų testai gali padėti jums aptikti su tipais susijusias klaidas ir užtikrinti, kad jūsų kodas veiktų taip, kaip tikėtasi. Yra daug bibliotekų, skirtų vienetų testavimui Typescript, tokių kaip Jest ir Mocha.

4. Nuolatinė integracija ir nuolatinis diegimas (CI/CD)

Įdiekite CI/CD konvejerį, kad automatizuotumėte kompiliavimo, testavimo ir diegimo procesą. Tai padės jums anksti aptikti klaidas ir užtikrinti, kad jūsų programa visada būtų diegimo būsenoje. Tokie įrankiai kaip Jenkins, GitLab CI ir GitHub Actions gali būti naudojami CI/CD konvejeriams kurti.

5. Stebėjimas ir registravimas

Įdiekite stebėjimą ir registravimą, kad galėtumėte stebėti savo programos našumą ir elgesį gamyboje. Tai padės jums nustatyti galimas problemas ir užtikrinti, kad jūsų programa veiktų sklandžiai. Tokie įrankiai kaip Prometheus ir Grafana gali būti naudojami stebėjimui, o tokie įrankiai kaip ELK Stack (Elasticsearch, Logstash, Kibana) gali būti naudojami registravimui.

Realaus pasaulio pavyzdžiai ir naudojimo atvejai

Štai keletas realaus pasaulio pavyzdžių, kaip TypeScript ir Docker gali būti naudojami kartu:

• Mikroservisų architektūra: TypeScript ir Docker puikiai tinka mikroservisų architektūroms. Kiekviena mikropaslauga gali būti kuriama kaip atskiras TypeScript projektas ir diegiama kaip Docker konteineris.
• Žiniatinklio programos: TypeScript gali būti naudojamas žiniatinklio programų priekinei ir galinei daliai kurti. Docker gali būti naudojamas programai konteinerizuoti ir ją diegti įvairiose aplinkose.
• Serverless funkcijos: TypeScript gali būti naudojamas serverless funkcijoms rašyti, kurios gali būti diegiamos kaip Docker konteineriai į serverless platformas, tokias kaip AWS Lambda arba Google Cloud Functions.
• Duomenų srautai: TypeScript gali būti naudojamas duomenų srautams kurti, kurie gali būti konteinerizuoti naudojant Docker ir diegiami duomenų apdorojimo platformose, tokiose kaip Apache Spark arba Apache Flink.

Pavyzdys: Globali e. komercijos platforma

Įsivaizduokite pasaulinę e. komercijos platformą, palaikančią kelias kalbas ir valiutas. Galinė dalis sukurta naudojant Node.js ir TypeScript, su skirtingomis mikropaslaugomis, apdorojančiomis produktų katalogą, užsakymų apdorojimą ir mokėjimo šliuzo integracijas. Kiekviena mikropaslauga yra konteinerizuota naudojant Docker, užtikrinant nuoseklų diegimą įvairiuose debesų regionuose (pvz., AWS Šiaurės Amerikoje, Azure Europoje ir Google Cloud Platform Azijoje). TypeScript tipo saugumas padeda išvengti klaidų, susijusių su valiutos konvertavimu ar lokalizuotais produktų aprašymais, o Docker garantuoja, kad kiekviena mikropaslauga veiks nuoseklioje aplinkoje, neatsižvelgiant į pagrindinę infrastruktūrą.

Pavyzdys: Tarptautinė logistikos programa

Apsvarstykite tarptautinę logistikos programą, sekančią siuntas visame pasaulyje. Programa naudoja TypeScript tiek priekinei, tiek galinei kūrimui. Priekinė dalis suteikia vartotojo sąsają siuntoms sekti, o galinė dalis apdoroja duomenis ir integruojasi su įvairiais siuntimo teikėjais (pvz., FedEx, DHL, UPS). Docker konteineriai naudojami programai diegti skirtinguose duomenų centruose visame pasaulyje, užtikrinant mažą delsą ir didelį pasiekiamumą. TypeScript padeda užtikrinti duomenų modelių, naudojamų siuntoms sekti, nuoseklumą, o Docker palengvina sklandų diegimą įvairiose infrastruktūrose.

Išvada

TypeScript integravimas su Docker suteikia galingą derinį patikimoms ir prižiūrimoms programoms kurti. Pasinaudodami TypeScript tipo saugumu ir Docker konteinerizacijos galimybėmis, kūrėjai gali kurti patikimesnes, lengviau diegiamas ir produktyviau kuriamas programas. Laikydamiesi šiame vadove aprašytų geriausių praktikų, galite efektyviai integruoti TypeScript ir Docker į savo kūrimo darbo eigą ir užtikrinti konteinerių tipo saugumą visą kūrimo ciklą.

Papildomi šaltiniai

• Oficiali TypeScript svetainė
• Oficiali Docker svetainė
• Docker Compose dokumentacija