Come creare un'applicazione Node.js con TypeScript e Docker

Blog

Come creare un'applicazione Node.js con TypeScript e Docker

Se non conosci il dattiloscritto, guarda questo tutorial che copre le basi di TypeScript.



Configurazione dell'applicazione

Per prima cosa, devi installare dattiloscritto nella tua macchina. Esegui il seguente comando, questo installerà dattiloscritto a livello globale nella tua macchina.

npm install -g typescript

Crea una directory e inizializza l'applicazione node.js con il comando.



bootstrap 4 input di tag
npm init --yes

Successivamente, è necessario creare un file di configurazione per dattiloscritto che compila il dattiloscritto in javascript.

tsc --init

creerà un file di configurazione chiamato tsconfig.json che contiene la configurazione TypeScript per l'applicazione.




Potrebbe piacerti anche: Docker per i progetti Node.js da un capitano Docker


Configurazione di TypeScript

Inoltre, il file di configurazione contiene le opzioni del compilatore che possono essere configurate. opzioni importanti sono,

  • obbiettivo – può essere ES6 o ES5, in base alle opzioni, TypeScript compila il codice su ES6 o ES5.
  • outDir – specifica la directory in cui verrà memorizzato il codice compilato.
  • rootDir – specifica la directory su cui si troverà il codice dattiloscritto.
  • moduloRisoluzione – specifica la strategia di risoluzione del modulo
    Questo è il titolo dell'immagine

Una volta, è configurato. abbiamo bisogno di installare alcune dipendenze per configurare ed eseguire il dattiloscritto sull'applicazione express.

Installa le seguenti dipendenze usando il comando

npm i -D typescript ts-node @types/node @types/express
  • ts-nodo – è un pacchetto per l'utilizzo di TypeScript con Node.js. possiamo eseguire l'applicazione usando ts-node app.ts
  • @tipi/nodo – definisce i tipi personalizzati per Node.js in dattiloscritto
  • @tipi/espresso – definisce i tipi personalizzati per l'applicazione espressa in dattiloscritto

Successivamente, crea uno script in package.json per compilare ed eseguire l'applicazione.

'scripts': { 'dev': 'ts-node src/app.ts', 'start': 'ts-node dist/app.js', 'build': 'tsc -p .' }

Creazione di un'applicazione Express con TypeScript
Una volta completata la configurazione di TypeScript, possiamo creare l'applicazione Express utilizzando TypeScript.

Crea una directory chiamata src che contiene i file TypeScript e aggiungi il app.ts file in quello.

bot di trading poloniex python
import express,{ Application,Request,Response,NextFunction } from 'express'; import bodyParser from 'body-parser'; const app : Application = express(); app.use(bodyParser.json()); app.use(bodyParser.urlencoded({ extended: true })); app.get('/',(req:Request,res : Response ) => { res.send('TS App is Running') }) const PORT = process.env.PORT; app.listen(PORT,() => { console.log(`server is running on PORT ${PORT}`) })

uno dei vantaggi dell'utilizzo di TypeScript è definire il tipo per la variabile (Controllo statico).

Qui l'istanza Express sarà di tipo Application, quindi la variabile deve essere di tipo Application. lo stesso vale per richiesta, risposta e funzione successiva (middleware).

Dopodiché, dobbiamo scrivere una logica per connettere il database. creare un file chiamato connect.ts e aggiungi il seguente codice,

import mongoose from 'mongoose'; type DBInput = { db : string; } export default({db} : DBInput) => { const connect = () => { mongoose .connect(db,{ useNewUrlParser : true }) .then(() => { return console.info(`Successfully connected to ${db}`); }) .catch((err) => { console.error(`Error connecting to database :`,err); return process.exit(1); }) }; connect(); mongoose.connection.on('disconnected',connect); }

DBInput è un tipo che accetta la variabile db come stringa. lo usiamo per connetterci con mongodb.

Dopodiché, crea le directory Controllori , Modelli , Itinerari e tipi nella directory principale.

  • Controllori – contiene tutta la business logic per l'applicazione
  • Modelli – contiene tutto lo Schema Database di Mongoose.
  • Itinerari – avrà tutti i percorsi API per l'applicazione
  • tipi – conterrà i tipi personalizzati utilizzati nell'applicazione
    creare un file User.mode.ts nella directory dei modelli e aggiungere il seguente codice,
import mongoose, { Schema,Document } from 'mongoose'; export interface IUser extends Document { email : String; firstName : String; lastName : String; } const UserSchema : Schema = new Schema({ email : { type : String, required : true, unique : true }, firstName : { type : String, required : true }, lastName : { type : String, required : true } }); export default mongoose.model('User',UserSchema);

In primo luogo, definiamo lo schema della mangusta per il modello utente e l'utente Interfaccia

In Controllori Directory, Crea Controller.utente.ts file e aggiungi il seguente codice

import User,{ IUser } from '../Models/User.model'; interface ICreateUserInput { email: IUser['email']; firstName: IUser['firstName']; lastName: IUser['lastName']; } async function CreateUser({ email, firstName, lastName }: ICreateUserInput): Promise { return User.create({ email, firstName, lastName }) .then((data: IUser) => { return data; }) .catch((error: Error) => { throw error; }); } export default { CreateUser };

Successivamente, crea un file index.ts nella directory Routes e aggiungi il seguente codice,

import { RoutesInput } from '../types/route'; import UserController from '../Controllers/User.controller'; export default ({ app } : RoutesInput) => { app.post('api/user',async(req,res) => { const user = await UserController.CreateUser({ firstName: req.body.firstName, lastName: req.body.lastName, email: req.body.email }); return res.send({ user }); }) }

PercorsiIngresso è un tipo personalizzato che definisce il tipo di applicazione espresso.

come acquistare un'armatura cripto

creare un file tipi.ts in tipi directory e aggiungere il codice,

import { Application } from 'express'; export type RoutesInput = { app: Application; };

aggiorna il** app.ts** con mongodb connessione e itinerari dell'applicazione.

import express,{ Application,Request,Response,NextFunction } from 'express'; import 'dotenv/config'; import bodyParser from 'body-parser'; import Routes from './Routes'; import Connect from './connect'; const app : Application = express(); app.use(bodyParser.json()); app.use(bodyParser.urlencoded({ extended: true })); app.get('/',(req:Request,res : Response ) => { res.send('TS App is Running') }) const PORT = process.env.PORT; const db = 'mongodb://localhost:27017/test'; Connect({ db }); Routes({ app }) app.listen(PORT,() => { console.log(`server is running on PORT ${PORT}`) })

Per testare l'applicazione, esegui lo script npm run dev e visita l'url http://localhost:4000

Configurazione Docker

Se non conosci la finestra mobile, leggi informazioni su docker per node.js e configurazione della finestra mobile .

combinazione di colori del codice dello studio visivo

creare un file Dockerfile nella directory principale e aggiungere il seguente codice.

FROM node:10 WORKDIR /usr/src/app COPY package.json ./ RUN npm install RUN npm install pm2 -g RUN npm run build COPY ./dist . EXPOSE 4000 CMD ['pm2-runtime','app.js']

Fondamentalmente, prendiamo l'immagine di base del nodo e installiamo tutte le nostre dipendenze nel contenitore dell'immagine docker

Successivamente, installiamo il gestore di processi chiamato pm2 che viene utilizzato principalmente in tutte le applicazioni di produzione. quindi copiamo il codice compilato dall'immagine locale all'immagine docker.

Inoltre, crea un file docker-compose.yml nella directory principale e aggiungere il seguente codice.

version: '3' services: app: container_name: app restart: always build: . environment: - PORT=4000 ports: - '4000:4000' links: - mongo mongo: container_name: mongo image: mongo ports: - '27017:27017'

Docker componi combina più servizi docker ed eseguilo in un unico contenitore. Qui, combiniamo MongoDB e le immagini dell'applicazione ed eseguiamo il contenitore.

Distribuzione e esecuzione di Docker

Una volta, viene aggiunto Dockerfile. eseguire il seguente comando,

docker-compose up

distribuirà il codice compilato nell'immagine docker e lo eseguirà nel contenitore.

pausa di sistema c++

Fonte completa codice contiene Creazione di una produzione - App Node.js pronta con TypeScript e Docker.

Originariamente pubblicato da ganeshmani009 a cloudnweb.dev

Impara di più

#node-js #docker #typescript