alcuni di essi e supporta più architetture (amd64, arm32v6, arm32v7, arm64v8 e s390x).
A partire da Node-RED 1.0, il repository su Docker Hub è stato rinominato nodered/node-red.
avvio rapido
Per eseguirlo in Docker nella sua forma più semplice, basta eseguire:
docker run -it -p 1880:1880 -v node_red_data:/data -name mynodered nodered/node-red
Analizziamo questo comando:
docker run - esegue il contenitore, costruendolo inizialmente in locale, se necessario.
-it - collega una sessione di terminale per vedere cosa sta succedendo
-p 1880:1880 - collega la porta locale 1880 alla porta interna esposta 1880
-v node_red_data:/data - monta un volume docker chiamato `node_red_data` nella directory /data del contenitore, in modo che qualsiasi modifica apportata ai flussi venga mantenuta.
-nome mynodered - assegna a questa macchina un nome locale amichevole
nodered/node-red - l'immagine su cui basarsi - attualmente Node-RED v1.2.0
Eseguendo questo comando si ottiene una finestra di terminale con un'istanza di Node-RED in esecuzione.
Benvenuti a Node-RED
===================
10 Oct 12:57:10 - [info] Versione di Node-RED: v1.2.0
10 Oct 12:57:10 - [info] Versione di Node.js: v10.22.1
10 Ott 12:57:10 - [info] Linux 4.19.76-linuxkit x64 LE
10 Oct 12:57:11 - [info] Caricamento dei nodi della tavolozza
10 Oct 12:57:16 - [info] File delle impostazioni: /data/settings.js
10 Oct 12:57:16 - [info] Negozio contestuale : 'default' [module=memory]
10 Oct 12:57:16 - [info] Directory utente : /data
10 Oct 12:57:16 - [warn] Progetti disabilitati : editorTheme.projects.enabled=false
10 Oct 12:57:16 - [info] File dei flussi : /data/flows.json
10 Oct 12:57:16 - [info] Creazione di un nuovo file di flusso
10 Oct 12:57:17 - [warn]
————————————————– ——————-
Il file delle credenziali del flusso viene crittografato utilizzando una chiave generata dal sistema.
Se la chiave generata dal sistema viene smarrita per qualsiasi motivo, le credenziali
il file non sarà recuperabile, sarà necessario cancellarlo e reinserirlo.
le vostre credenziali.
È necessario impostare la propria chiave utilizzando l'opzione "credentialSecret" in
il file delle impostazioni. Node-RED provvederà quindi a criptare nuovamente le credenziali.
utilizzando la chiave scelta la prossima volta che si distribuisce una modifica.
————————————————– ——————-
10 Oct 12:57:17 - [info] Avvio dei flussi
10 Oct 12:57:17 - [info] Flussi avviati
10 Oct 12:57:17 - [info] Il server è ora in esecuzione a http://127.0.0.1:1880/
[…]
Si può quindi navigare all'indirizzo http://{host-ip}:1880 per ottenere il familiare desktop di Node-RED.
Il vantaggio è che, dandogli un nome (mynodered), possiamo manipolarlo più facilmente e, fissando, conosciamo la porta dell'host con cui abbiamo familiarità. Naturalmente, questo significa che possiamo eseguire solo un'istanza alla volta... ma solo un passo alla volta.
Se siamo soddisfatti di ciò che vediamo, possiamo cambiare il terminale con Ctrl-p Ctrl-q- e il contenitore continuerà a funzionare in background.
Per ricollegarsi al terminale (visualizzare la registrazione), eseguire:
docker attach mynodered
Se è necessario riavviare il contenitore (ad esempio dopo il riavvio o il riavvio del demone Docker):
docker avvia mynodered
e fermarsi di nuovo se necessario:
docker stop mynodered
Modifiche all'immagine
Le immagini Node-RED sono basate sulle immagini ufficiali di Node JS Alpine Linux per mantenerle il più piccole possibile. L'uso di Alpine Linux riduce le dimensioni dell'immagine costruita, ma rimuove le dipendenze standard necessarie per la compilazione nativa dei moduli. Se si desidera aggiungere dipendenze native, estendere l'immagine Node-RED con i pacchetti mancanti sul contenitore in esecuzione o costruire una nuova immagine, vedere docker -custom che si trova nel README.md del progetto Docker Node-RED ampliato.
Per immagini dettagliate, tag e informazioni sul manifesto, vedere il readme del progetto su Github.
Per esempio: Si supponga di utilizzare un Raspberry PI 3B con architettura arm32v7as. Basta eseguire il seguente comando per estrarre l'immagine (contrassegnata da 1.2.0-10-arm32v7) ed eseguire il contenitore.
docker run -it -p 1880:1880 -v node_red_data:/data -name mynodered nodered/node-red:latest
Lo stesso comando può essere usato per funzionare su un sistema amd64, poiché Docker scopre che è in esecuzione su un host amd64 e preleva l'immagine con l'etichetta corrispondente (1.2.0-10-amd64).
Il vantaggio è che non è necessario conoscere/specificare l'architettura su cui si sta operando e rende il comando docker run e i file docker compose più flessibili e intercambiabili tra i vari sistemi.
Nota: attualmente esiste un bug nel rilevamento dell'architettura di Docker per arm32v6, come Raspberry Pi zero o uno. Per questi dispositivi, attualmente è necessario specificare il tag dell'immagine completa, ad esempio:
docker run -it -p 1880:1880 -v node_red_data:/data -name mynodered nodered/node-red:1.2.0-10-arm32v6
Gestire i dati degli utenti
Dopo aver eseguito Node-RED con Docker, dobbiamo assicurarci che i nodi o i flussi aggiunti non vadano persi se il contenitore viene distrutto. I dati dell'utente possono essere salvati montando la directory dei dati su un volume esterno al contenitore. Questo può essere fatto usando i montaggi bind o i volumi di dati denominati.
Node-RED utilizza la directory all'interno del contenitore /data per memorizzare i dati di configurazione dell'utente.
Utilizzo della directory host per la persistenza (bind mount)
Per salvare la cartella utente di Node-RED all'interno del contenitore nella cartella host fuori dal contenitore, si può usare il seguente comando. Per consentire l'accesso a questa directory host, l'utente node-red all'interno del contenitore (default uid=1000) deve avere lo stesso uid del proprietario della directory host.
docker run -it -p 1880:1880 -v /home/pi/.node-red:/data -name mynodered nodered/node-red
In questo esempio, la cartella host /home/pi/.node-red è legata alla cartella container /data.
Nota: gli utenti che migrano dalla versione 0.20 alla versione 1.0 devono assicurarsi che le directory /data esistenti abbiano la proprietà corretta. A partire dalla 1.0 questa deve essere 1000:1000. Questo può essere forzato con il comando sudo chown -R 1000:1000 path/to/your/node-red/data
Per maggiori dettagli sui permessi, consultare il wiki.
Utilizzare volumi di dati denominati
Docker supporta anche l'uso di volumi di dati denominati per memorizzare dati persistenti o condivisi al di fuori del contenitore.
Creare un nuovo volume di dati con nome per contenere i dati degli utenti ed eseguire un nuovo contenitore utilizzando questo volume.
$ docker volume create -name node_red_data
$ docker volume ls
NOME DEL VOLUME DEL DRIVER
nodo_rosso_dati
$ docker run -it -p 1880:1880 -v node_red_data:/data -name mynodered nodered/node-red
Se è necessario eseguire il backup dei dati da un volume montato, è possibile accedervi mentre il contenitore è in esecuzione.
$ docker cpmynodered:/data/il tuo/backup/directory
Utilizzando Node-RED per creare e distribuire alcuni processi di esempio, possiamo ora distruggere il contenitore e avviare una nuova istanza senza perdere i dati degli utenti.
$ docker stop mynodered
$ docker rm mynodered
$ docker run -it -p 1880:1880 -v node_red_data:/data -name mynodered nodered/node-red
rinnovare
Dal momento che /data è ora conservato al di fuori del contenitore, l'aggiornamento dell'immagine del contenitore di base è ora come
$ docker pull nodered/node-red
$ docker stop mynodered
$ docker rm mynodered
$ docker run -it -p 1880:1880 -v node_red_data:/data -name mynodered nodered/node-red
Stack Docker/Scritto Docker
Di seguito è riportato un esempio di file Docker Compose che può essere eseguito da docker stack o docker-compose. Per ulteriori informazioni su Docker stack e Docker compose, consultare la pagina ufficiale di Docker.
################################################ ############################### Node-RED Stack o Compose#####1T####1T#1T#1T#1T#1T#1T# ################################################ #################1T#1T##1T## docker stack deploy node-red -compose-file docker-compose-node-red.yml# docker-compose -f docker-compose-node-red.yml -p myNoderedProject up########################################## ####################################version: "3.7 "Servizi:
nodo rosso:
immagine: nodered/node-red:latest
ambiente:
- TZ=Europa/Amsterdam
porti:
– “1880:1880”
reti:
-nodo-rosso-rete
volumi:
- nodo-rosso-dati:/datavolumi:
node-red-data:reti:
nodo-rosso-rete:
Comporre il file di cui sopra:
Creare il servizio nodo rosso
Estrarre l'ultima immagine rossa del nodo
Impostare il fuso orario su Europa/Amsterdam
Mappare la porta 1880 del contenitore sulla porta 1880 dell'host
Creare una rete node-red-net e collegarvi il contenitore
/data persiste la directory all'interno del contenitore in un volume in node-red-dataDocker
Profilo Docker copiato nelle risorse locali
A volte è utile popolare l'immagine Docker di Node-RED con i file di una directory locale (per esempio, se si vuole mantenere l'intero progetto in un repository git). Per questo è necessaria una directory locale come questa:
Profilo Docker
README.md
package.json # aggiungere tutti i nodi extra di cui il flusso ha bisogno nel proprio package.json.
flows.json # il posto normale in cui Node-RED memorizza i flussi
flows_cred.json # credenziali di cui i flussi potrebbero aver bisogno
settings.js # il vostro file di impostazioni
Nota: Questo metodo non è adatto se si desidera montare il volume /data esternamente. Se è necessario utilizzare un volume esterno per la persistenza, copiare le impostazioni e i file di flusso su tale volume.
Il seguente file Docker si basa sull'immagine Docker di base di Node-RED, ma in aggiunta sposta i propri file nell'immagine:
DA nodered/node-red
# Copiare il file package.json nella WORKDIR in modo che npm costruisca tutti i file
# dei moduli dei nodi aggiunti per Node-RED
COPIA pacchetto.json .
ESEGUIRE npm install -unsafe-perm -no-update-notifier -no-fund -only=production
# Copiare i file del progetto Node-RED al suo posto
# NOTA: questo funziona solo se NON si monta successivamente /data come volume esterno.
# Se è necessario utilizzare un volume esterno per la persistenza, allora
# copiare invece le impostazioni e i file di flusso su quel volume.
COPIA settings.js /data/settings.js
COPIA flussi_cred.json /dati/flussi_cred.json
COPIA flussi.json /dati/flussi.json
# Si dovrebbero aggiungere nodi extra tramite il file package.json, ma si possono aggiungere anche qui:
#WORKDIR /usr/src/node-red
#RUN npm installare node-red-node-smooth
NOTA: Il file package.json deve contenere un'opzione di lancio nella sezione script. Ad esempio, il contenitore predefinito ha questo aspetto:
"script": {
"start": "node $NODE_OPTIONS node_modules/node-red/red.js $FLOWS",
…
Ordine dei file Docker e velocità di compilazione
Anche se non è necessario, è una buona idea COPIARE package... npm install... per eseguire questi passaggi in anticipo, perché mentre flows.json cambia spesso quando si lavora in Node-RED, package.json cambia solo quando i moduli del progetto vengono modificati. cambierà. E poiché i passaggi da eseguire quando si modifica npm install package.json a volte possono richiedere molto tempo, è una buona idea eseguire i passaggi più lunghi e spesso invariati prima nel file Docker, in modo che queste immagini di build possano essere riutilizzate, rendendo la compilazione successiva più veloce.
Credenziali, segreti e variabili d'ambiente
Naturalmente, non si vuole mai codificare le credenziali da nessuna parte, quindi se si ha bisogno di usare le credenziali in un progetto Node-RED, il file Docker di cui sopra consente di farlo nel file settings.js...
module.exports = {
credentialSecret: process.env.NODE_RED_CREDENTIAL_SECRET // aggiungiamo esattamente questo
}
...e poi quando si esegue in Docker, si aggiunge una variabile d'ambiente al comando di esecuzione...
docker run -e "NODE_RED_CREDENTIAL_SECRET=il_tuo_segreto_vuol_essere_qui"
Costruire ed eseguire
In genere si costruisce questo file Docker:
docker build -t your-image-name:your-tag .
Per eseguire localmente lo sviluppo, dove le modifiche vengono scritte immediatamente e solo cd alla directory del progetto dalla directory locale in cui si sta lavorando, quindi eseguire:
docker run -rm -e "NODE_RED_CREDENTIAL_SECRET=tuo_segreto_vuoi_qui" -p 1880:1880 -v `pwd`:/data -name a-container-name your-image-name
avvio
Le variabili d'ambiente possono essere passate nel contenitore per configurare il runtime di Node-RED.
Il file di configurazione dei flussi viene impostato tramite il parametro d'ambiente ( FLOWS ), che per impostazione predefinita è 'flows.json'. Questo parametro può essere modificato in fase di esecuzione utilizzando i seguenti flag della riga di comando.
docker run -it -p 1880:1880 -v node_red_data:/data -e FLOWS=my_flows.json nodered/node-red
Nota: se si imposta -e FLOWS="", è possibile impostare il flusso tramite la proprietà flowFile nel file settings.js.
Altre variabili d'ambiente utili sono
-e NODE_RED_ENABLE_SAFE_MODE=false# Impostare su true per avviare Node-RED in modalità sicura (non in esecuzione)
-e NODE_RED_ENABLE_PROJECTS=false # Impostare su true per avviare Node-RED e abilitare le funzioni dei progetti
I parametri di runtime di Node.js possono essere passati al contenitore tramite parametri d'ambiente (NODE_OPTIONS). Per esempio, per fissare la dimensione dell'heap usata dal garbage collector di Node.js, si può usare il seguente comando.
docker run -it -p 1880:1880 -v node_red_data:/data -e NODE_OPTIONS="-max_old_space_size=128″ nodered/node-red
Parole chiave: gateway industriale