Hello, in this tutorial, we are going to see how we can run Node-RED in a Docker container. For this tutorial, I would

assume that you already have Docker installed on your computer. As you can see, mine is already installed here. I also have Docker Desktop here; I have

a few images. I have a Postgres image here; I have a MongoDB image here as well, so

you have to have your Docker installed and running already. So, to run Node-RED in a Docker container, we would need the

Docker image. So, fortunately, there is already a Node-RED Docker image on Docker Hub. So, what we need to do is just

to pull that image and then use it. It's the official Node-RED Docker image. I will open my PowerShell

here, and all we have to do is to use the Docker command, the `pull` command, and then we specify the name of the image. So,

the name of the image on Docker is `node-red/node-red`, just like that. So, `docker pull node-red/`,

rather `node-red/node-red`, and then we click Enter, and then it will pull the latest image. As you can see here with the

latest tag there, it's pulling now the image, and very soon we should be able to see the image in our Docker Desktop

there. So let's wait until the image has been pulled, and then we proceed. So, after a few more minutes, um, you can see that

the download has completed, as you can see from the status here. And if we go back to our Docker Desktop, we can see we have

a new image here, `node-red/node-red`, and now we are ready to create a container, run Node-RED in that

container, and do a variety of things with our Node-RED. And to run, to create a container from this image, we go back

here to our PowerShell or whatever console you're using for that case, and we use the following command. So we said `docker`

'-d' means detached, so we're starting the container in detached mode.  We shall not see any logging on the console.

The first thing we need to do is map ports. So we'll say '-p'

and the first port we map is 1880. We map it to 1880. So we are mapping

port 1880 of the Docker container—the internal port of the Docker container—to our local machine port. This is

the port of the local Docker container. We're mapping it to the port of our local machine. This is the case because

the Node-RED desktop runs on this port, and for us to access the Node-RED desktop, we need to have access

to that port. That is why we're mapping it to our local machine port. In other words, we're exposing the Docker

container's local port so that we have access to it. That's what we're doing here. And then, if you have

any other services that you want to connect to externally from the Docker container, you must also map those

ports on which the services are running. For example, we shall be using Modbus TCP, and the port we shall be using for Modbus TCP is 502. So we have to map that port as well.

So say again '-p 502' mapped to 502. So we are mapping the Docker container port 502 to our local machine port 502 so that we expose

that port to the external environment so communication can go both ways: either from the Docker container to the external environment or from the external environment to the Docker

container. So that is all we are going to do for the moment with the port mapping. And then the other thing we need

Uh, for persistent data, Node-RED needs a volume to store this persistent data, and we shall create a new volume. So we

shall say `-v`, and we shall... the volume should be written like `node-red-data:/data`. So that

means we've mounted a volume called `node-red-data` to the container's `/data` directory. So that is what we've done here. So the

um, this volume will be used to store flows persistently. Flows are... we shall see what flows are in Node-RED, but that is exactly

what it does.  In other words, storing persistent data used by Node-RED, uh, there persistently, and

then we select the name of our Node-RED container. So, say `--name`, and we shall call this

Node-RED-PJ. You can call it whatever you want; I just call it Node-RED-PJ, and

then now the last part is to specify the image we're creating the container from, and this is... we already know what it is: it's

Node-RED.  Just like that. And that's our command complete. So a

simple recap: we run the `docker run` command. `-d` (detached), `-p`, we start mapping ports and exposing ports

from the Docker container to the external environment and vice versa. So we've mapped two ports, basically. We've

mapped port 1880, where the Node-RED desktop... so we can access it from the external environment. We've mapped port 502 as well, because that is where we shall have our Modbus communication running. And then we

created a volume here that is mapped to the `/data` directory, since the `/data` directory is a container directory. So we're mapping

it to this volume that we've created, and that is for persistent data storage. And then `--name`, we specify

The name of our Node-RED container, and then we specify the image name here. Then we just click Enter, and that should

create for us our container, and it should also run it. So let's check whether it's started. So these are images; we come to

containers. We can see we have a bunch of other containers here, but we have our Node-RED container, and it shows here that it's

running already. So no errors whatsoever; everything is running correctly, and it shows all the ports that have been mapped. So you can see them here. So if

you're working in Docker Desktop, rather, you can control or manage this container the way you want. You can stop it from here,

you can start it from here. But if you don't have Docker Desktop, for example, you can do a lot of things here. You can

find information about the status of the container and everything like that. So you can just, for example, if you want to

see containers that are running, you can just type `docker ps`, and you can see basically the information about our

container here. You can see the container ID here, the image it's created from, and everything like that.

And you can see the ports here that are mapped as well, and the name of the container here. So, status as well; you can

see it's up about a minute and it's healthy; that means it's running. If you want to stop the container, you can

just say `docker stop`, and then you specify the name of the container. So you say `docker stop node-red-pg`, and then it will stop. If you want to run it again, so instead

of `stop`, now you just say `start`. So `docker start node-red-pg`, and then it will start again. So that is how you

manage the container if you don't have Docker Desktop. But if you have Docker Desktop, then it's very easy to manage it.

From here, now that we've started our container and it's running, let's test it out. To test the container, we

just basically need to specify `localhost:1880`. That is the port where the

Docker, rather the Node-RED desktop, is running from. Then we just click Enter, and that should load our

Docker desktop. As you can see here, we have our Docker desktop; we have some flows here. So I have some persistent

data in the volume I created earlier. So my persistent data is still there, as you can see.

Everything is saved in there. We can create a new flow; we have nodes here, several nodes, and everything

is running fine. We shall create several projects with this Node-RED. For the moment, I'll leave this as is. We've

managed to pull our image, created our container, and then

tested it out, and we can see that we have access to the Node-RED desktop. So that is it for this short tutorial.

In the next tutorial, we are going to start creating different projects in Node-RED, and let's see how things go. But for this

tutorial, this is quite enough. Thank you, and have a nice day.

How to Run Node-Red in a Docker Container - Build Node-Red Applications in a Docker Container

Welcome to my channel. This channel dedicated to Industrial Automation Tutorials,  Robotics, Factory automation, Python tutorials, C Programming, Codesys and PLC Programming, Industrial applications Development based on the IEC 61131-3 Standard: Ladder Diagram, Structured Text, Function Block, Sequential Function Chart & Instruction List languages.

I am also a huge Train and Tram enthusiast and and everything urban transport, so you may sometime see a few clips related to such adventures
