Knoten-und Andockfenster - zu behandeln, wie babel oder Typoskript bauen?

Habe ich eine Knoten-Anwendung, die ich hosten möchten, die in einem Docker-container, die sollte unkompliziert sein, wie in diesem Artikel gesehen:

https://nodejs.org/en/docs/guides/nodejs-docker-webapp/

In meinem Projekt, aber die Quellen können nicht direkt betrieben werden, Sie muss kompiliert werden, von ES6 und/oder Typoskript. Ich benutze Schluck zu bauen mit babel, browserify und tsify - mit unterschiedlichen setups für browser und server.

Was wäre der beste workflow für den Aufbau und Automatisierung docker-images in diesem Fall? Gibt es irgendwelche Ressourcen auf dem web, das beschreibt, wie ein workflow? Sollte die Dockerimage tun, das Gebäude nach npm install oder sollte ich ein shell-Skript, um all dies zu tun und haben einfach nur das Dockerfile pack Sie alle zusammen?

Wenn das Dockerfile sollte die bauen - das Bild würde müssen enthalten alle dev-Abhängigkeiten, die nicht ideal sind?

Hinweis: ich habe in der Lage, eine docker-container, und führen Sie es - aber das erforderte alle Dateien werden installiert und gebaut vorher.

InformationsquelleAutor Jørgen Tvedt | 2016-05-24

10

Eine mögliche Lösung ist, wickeln Sie Ihre build-Verfahren in einer speziellen docker image. Es ist oft bezeichnet als - generator Bild. Es sollte enthalten alle Ihre build-Abhängigkeiten: nodejs, npm, schlucken, babel, tsc und etc. Es kapselt alle build-Prozess, wodurch die Notwendigkeit für die Installation dieser tools auf dem host.

Zuerst führen Sie den generator Bild ist die Montage des source-code-Verzeichnis als volume. Das gleiche oder ein unterschiedliches Volumen verwendet werden können als Ausgabe-Verzeichnis.
Das erste Bild findet Ihr code und führt alle Befehle zum erstellen von.

Als ersten Schritt nehmen Sie Ihre erstellte code und packen es in die Produktion Andockfenster Bild, wie Sie es jetzt tun.

Hier ist ein Beispiel von docker image builder für die Niederschrift: https://hub.docker.com/r/sandrokeil/typescript/

Es ist ok, um den gleichen docker-generator für mehrere Projekte, wie es ist in der Regel entwickelt, um Allzweck-wrapper um einige Allgemeine Werkzeuge.
Aber es ist ok, Ihre eigenen zu bauen, der beschreibt, mehr komplizierte Verfahren.

Die gute Sache über image builder ist, dass Ihre host-Umgebung bleibt unbelastet und sind Sie frei, um zu versuchen neuere Versionen der compiler/andere Extras/Reihenfolge ändern/Aufgaben parallel, nur durch modifing Dockerfile Ihrer builder-Bild. Und jederzeit können Sie rollback Ihres Experiments mit build-Verfahren.
- Ich nehme es, dass Sie vorschlagen, einen separaten docker-image für den build-Prozess kann gestartet werden, es zu tun zu bauen. Dann die eigentliche Produktion-image enthält diese build output?
- Sie sind frei, um beliebige Inhalte, die in der Produktion Bild. Es verwendet eine separate Dockerfile, so können Sie beide build-Ausgabe und einige original-Dateien (config Dateien und etc.)
InformationsquelleAutor gerichhome

Ich persönlich bevorzugen, entfernen Sie einfach das dev-Abhängigkeiten nach der Ausführung babel beim bauen:

FROM node:7

# Create app directory
RUN mkdir -p /usr/src/app
WORKDIR /usr/src/app

# Install app dependencies
COPY package.json /usr/src/app/
RUN npm install

# Copy app source
COPY src /usr/src/app/src

# Compile app sources
RUN npm run compile

# Remove dev dependencies
RUN npm prune --production

# Expose port and CMD
EXPOSE 8080
CMD [ "npm", "start" ]

FYI WORKDIR macht das Verzeichnis, falls es nicht vorhanden ist, also das mkdir ist unnötig

InformationsquelleAutor Lukas Hechenberger

Die moderne Empfehlung für diese Art der Sache (wie von Docker 17.05) ist die Verwendung eines multi-stage bauen. Auf diese Weise können Sie alle Ihre dev/build-Abhängigkeiten in einem Dockerfile, sondern haben das Endergebnis optimiert und frei von unnötigen code.

Ich bin nicht so vertraut mit typescript, aber hier ist eine Beispiel-Implementierung mit Garn und babel. Mithilfe dieses Dockerfile, können wir bauen ein Bild Entwicklung (mit docker build --target development .) für die Ausführung nodemon, tests etc. vor Ort, aber mit einer geraden docker build . bekommen wir eine schlanke, optimierte Produktionsprozesse Bild, läuft die app mit pm2.

# common base image for development and production
FROM node:10.11.0-alpine AS base
WORKDIR /app


# dev image contains everything needed for testing, development and building
FROM base AS development
COPY package.json yarn.lock ./

# first set aside prod dependencies so we can copy in to the prod image
RUN yarn install --pure-lockfile --production
RUN cp -R node_modules /tmp/node_modules

# install all dependencies and add source code
RUN yarn install --pure-lockfile
COPY . .


# builder runs unit tests and linter, then builds production code 
FROM development as builder
RUN yarn lint
RUN yarn test:unit --colors
RUN yarn babel ./src --out-dir ./dist --copy-files


# release includes bare minimum required to run the app, copied from builder
FROM base AS release
COPY --from=builder /tmp/node_modules ./node_modules
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/package.json ./
CMD ["yarn", "pm2-runtime", "dist/index.js"]

InformationsquelleAutor Greg

Gehen Sie folgendermaßen vor:

Schritt 1: stellen Sie sicher, dass Sie den babel Abhängigkeiten innerhalb der Abhängigkeiten nicht dev Abhängigkeiten auf der Packung.json. Auch eine deploy-Skript, das die Referenzierung von babel von den node_modules-Ordner. Sie rufen dieses script aus innerhalb von docker
Dies ist, was mein Paket.json-Datei sieht wie

{
  "name": "tmeasy_api",
  "version": "1.0.0",
  "description": "Trade made easy Application",
  "main": "build/index.js",
  "scripts": {    
     "build": "babel -w src/-d build/-s inline",
    "deploy" : "node_modules/babel-cli/bin/babel.js src/-d build/",
  },
  "devDependencies": {   
    "nodemon": "^1.9.2"
  },
  "dependencies": {    
    "babel-cli": "^6.10.1",
    "babel-polyfill": "^6.9.1",
    "babel-preset-es2015": "^6.9.0",
    "babel-preset-stage-0": "^6.5.0",
    "babel-preset-stage-3": "^6.22.0"
  }
}

bauen ist für Ihre Entwicklung auf Ihrem lokalen Rechner und bereitstellen aufgerufen werden, das aus Euch dockerfile.

Schritt 2: da wir wollen, um die babael transformation uns stellen Sie sicher, hinzufügen .dockerignore mit der build-Ordner, den Sie verwenden, während der Entwicklung.
Dies ist, was mein .dockerignore Datei aussieht.

    build
    node_modules

Schritt 3. Erstellen Sie Ihre dockerfile. unten ist ein Beispiel der Hafenarbeiter Datei

FROM node:6

MAINTAINER stackoverflow

ENV NODE_ENV=production
ENV PORT=3000

# use changes to package.json to force Docker not to use the cache
# when we change our application's nodejs dependencies:

ADD package.json /tmp/package.json
RUN cd /tmp && npm install
RUN mkdir -p /var/www && cp -a /tmp/node_modules /var/www

# copy current working directory into docker; but it first checks for  
# .dockerignore so build will not be included.

COPY      . /var/www/
WORKDIR   /var/www/

# remove any previous builds and create a new build folder and then
# call our node script deploy

RUN rm -f build
RUN mkdir build
RUN chmod 777 /var/www/build
RUN npm run deploy

VOLUME    /var/www/uploads
EXPOSE $PORT


ENTRYPOINT ["node","build/index.js"]

InformationsquelleAutor Derese Getachew

Ich soeben einen großen Samen-app für Typescript und Node.js mit Docker.

Finden Sie es auf GitHub.

Projekt erklärt alle Befehle, die Dockerfile verwendet und kombiniert tsc mit gulp für einige zusätzliche Vorteile.

Wenn Sie nicht wollen, um zu überprüfen, aus der repo, hier die details:

Dockerfile

FROM node:8

ENV USER=app

ENV SUBDIR=appDir

RUN useradd --user-group --create-home --shell /bin/false $USER &&\
    npm install --global tsc-watch npm ntypescript typescript gulp-cli

ENV HOME=/home/$USER

COPY package.json gulpfile.js $HOME/$SUBDIR/

RUN chown -R $USER:$USER $HOME/*

USER $USER

WORKDIR $HOME/$SUBDIR

RUN npm install

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

docker-Komponieren.yml

version: '3.1'

services:
  app:
    build: .
    command: npm run build
    environment:
      NODE_ENV: development
    ports:
      - '3000:3000'
    volumes:
      - .:/home/app/appDir
      - /home/app/appDir/node_modules

Paket.json

{
  "name": "docker-node-typescript",
  "version": "1.0.0",
  "description": "",
  "scripts": {
    "build": "gulp copy; gulp watch & tsc-watch -p . --onSuccess \"node dist/index.js\"",
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "Stephen Gardner ([email protected])",
  "license": "ISC",
  "dependencies": {
    "express": "^4.10.2",
    "gulp": "^3.9.1",
    "socket.io": "^1.2.0"
  },
  "devDependencies": {
    "@types/express": "^4.11.0",
    "@types/node": "^8.5.8"
  }
}

tsconfig.json

{
  "compileOnSave": false,
  "compilerOptions": {
    "outDir": "./dist/",
    "sourceMap": true,
    "declaration": false,
    "module": "commonjs",
    "moduleResolution": "node",
    "emitDecoratorMetadata": true,
    "experimentalDecorators": true,
    "target": "ES6"
  },
  "include": [
    "**/*.ts"
  ],
  "exclude": [
    "node_modules",
    "**/*.spec.ts"
  ]
}

Mehr zu bekommen zu der Antwort deiner Frage -- der ts ist zusammengestellt aus den docker-compose.yml Datei aufrufen von npm run build die ruft dann tsc. tsc kopiert dann die Dateien auf die dist Ordner und eine einfache node dist/index.js Befehl wird diese Datei. Anstelle der Verwendung von nodemon, verwenden wir tsc-watch und gulp.watch zu beobachten, für änderungen in der app und Feuer node dist/index.js wieder nach jedem re-compilation.

Hoffe, das hilft 🙂 Wenn Sie irgendwelche Fragen haben, lassen Sie es mich wissen!

Hi, Danke für das teilen! Es hilft mir sehr. Ein Hinweis: für Projekte mit einer langen Entwicklungs-Prozess, den ich empfehlen die Verwendung von LTS-version. Für die Knoten ist es Carbon. Knoten empfehlen, diese auch auf Ihre nodejs mit docker guide: nodejs.org/en/docs/guides/nodejs-docker-webapp
Danke, Stan - ich werde das ausprobieren, heute Abend und update mein repo 🙂

InformationsquelleAutor Augie Gardner

2

Für den moment, ich bin mit einem workflow, bei dem:
1. npm install und tsd install lokal
2. gulp bauen lokal
3. Im Dockerfile, kopieren Sie alle Programme, aber nicht Testungen/node_modules zu Andockfenster Bild
4. Im Dockerfile, npm install --production
Diese Weise bekomme ich nur die gewünschten Dateien in das Bild, aber es wäre schöner, wenn das Dockerfile tun konnte, die sich selbst aufbauen.

Dockerfile:
```
FROM node:5.1

# Create app directory
RUN mkdir -p /usr/src/app
WORKDIR /usr/src/app

# Bundle app
COPY package.json index.js /usr/src/app/
COPY views//usr/src/app/views/
COPY build//usr/src/app/build/
COPY public//usr/src/app/public/

# Install app dependencies
RUN npm install --production --silent

EXPOSE 3000
CMD [ "node", "index.js" ]
```
Ich denke, eine komplette Automatisierung in der "bildgebenden Verfahren" könnte geschaffen werden durch den Bau in die Dockerimage Skript und dann das löschen der unerwünschten Dateien, bevor Sie Sie erneut installieren.

InformationsquelleAutor Jørgen Tvedt
0

In meinem Projekt, aber die Quellen können nicht direkt betrieben werden, Sie muss kompiliert werden, von ES6 und/oder Typoskript. Ich benutze Schluck zu bauen mit babel, browserify und tsify - mit unterschiedlichen setups für browser und server. Was wäre der beste workflow für das erstellen und automatisieren von docker-images in diesem Fall?

Wenn ich verstehe Sie richtig, Sie wollen die Bereitstellung Ihrer web-app innerhalb eines Docker-container und bieten verschiedene Geschmacksrichtungen für verschiedene Ziel-Umgebungen (die Sie erwähnt verschiedene browser und server). (1)

Wenn das Dockerfile sollte die bauen - das Bild würde müssen enthalten alle dev-Abhängigkeiten, die nicht ideal sind?

Kommt es an. Wenn Sie möchten, um eine ready-to-go-Bild, es hat zu enthalten alles, was Sie Ihre web-app ausgeführt werden muss. Ein Vorteil ist, dass Sie später nur noch starten müssen die container, einige Parameter, und Sie sind bereit zu gehen.

Während der Entwicklungsphase, das Bild ist nicht wirklich nötig, weil Ihr in der Regel vorab definierten dev-Umgebung. Es kostet Zeit und Ressourcen, wenn Sie erzeugen ein solches Bild nach jeder änderung.

Vorgeschlagener Ansatz: ich würde vorschlagen, ein zwei-Wege-setup:
1. Während der Entwicklung: Verwenden Sie eine Feste Umgebung für die Entwicklung Ihrer app. Alle software kann lokal oder in einem Andockfenster/VM. Ich schlage vor, mit ein Docker-container mit Ihren dev-setup, vor allem, wenn Sie in einem team arbeiten und jeder braucht die gleichen dev-Keller.
2. - Deploy-Web-app: Als ich Sie richtig verstanden (1), die Sie bereitstellen möchten, die app für verschiedene Umgebungen und müssen daher, um zu erstellen/ermöglichen verschiedene Konfigurationen. Zu erkennen, so etwas wie, dass, man startet mit einem shell-script die Pakete, Ihre app in verschiedene docker-container. Sie das Skript ausführen, bevor Sie Ihre bereitstellen. Wenn Sie Jekyll läuft, ruft Sie Ihre shell-Skript nach jedem commit, nachdem alle tests liefen gut.
Docker-container für die Entwicklung und Bereitstellung phase: ich möchte verweisen auf ein Projekt von mir und einem Kollegen: https://github.com/k00ni/Docker-Nodejs-environment

Dieses Andockfenster bietet eine ganze Entwicklung - und deploy-Umgebung, indem Sie die Erhaltung:
- Node.js
- NPM
- Schluck
- Babel (auto transpiling von ECMA6 JavaScript zu einer Datei ändern)
- Webpack
und andere JavaScript-Helfer innen der docker-container. Sie einfach link zu Ihrem Projekt-Ordner über ein Volumen innerhalb des docker-container. Es initialisiert Ihrer Umgebung (z.B. setzt alle Abhängigkeiten aus dem Paket.json) und Sie sind gut zu gehen.

Können Sie es verwenden, für Entwicklung Zwecke, so dass Sie und Ihr team sind mit der gleichen Umgebung (Node.js version, NPM version,...) ein Weiterer Vorteil ist, dass die Datei änderungen führen zu einer re-kompilieren von ECMA6/ReactJS/... - Dateien, JavaScript-Dateien (Keine Notwendigkeit, dies zu tun mit der hand nach jeder änderung). Wir verwenden Babel dafür.

Für Bereitstellung Zwecke, verlängern Sie einfach das Docker-image und ändern benötigten Teile. Statt der Verknüpfung Ihrer app im inneren des Behälters, ziehen Sie es über Git (oder so ähnlich). Verwenden Sie den gleichen Keller für Ihre Arbeit.

InformationsquelleAutor k00ni

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.