i have a problem when start node with forever in docker container, if i launch manually works, instead the same command in Dockerfile, when build and start the container, exited.
The command works in bash:
docker run -it container_name bash forever start -c 'node --harmony' /my/path/app.js
I tried to put command in Dockerfile but the container don't start
CMD forever start -c 'node --harmony' /my/path/app.js
Google Group discussion
Forever start script.js runs in the background. To run forever in the foreground, try forever script.js.
This starts forever in the foreground, which is what Docker needs. Remember a container is "alive" only as long as the process defined in CMD is up and running. Since forever starts as a daemon, the command itself exits and docker will exit also.
CMD forever -c 'node --harmony' /my/path/app.js
Try using the array syntax:
CMD ["forever", "start", "-c", "node --harmony", "/my/path/app.js"]
I'm now trying to use forever in docker. This works:
CMD ["forever", "src/app.js"]
Put in your Dockerfile :
CMD forever app.js
Related
So I am facing a weird problem. I am starting a docker container with a entrypoint file and a env variable edgeboxId. The entrypoint.sh contains some pm2 commands to start my nodejs application.
Entrypoint.sh
#!/bin/bash
sudo -u deploy bash << EOF
cd /home/deploy/ce-edgebox-agent
pm2 start ecosystem.json
EOF
echo "out of the deploy user"
echo Entering Entryopint file
echo "export edgeboxId=$edgeboxId">> /etc/bash.bashrc
sudo -u edgebox bash << EOF
pm2 start ce-edgebox-application --update-env
EOF
echo "out of application user"
sleep infinity
Inside dockerfile, I am using following line to import entrypoint.sh file.
RUN ["chmod", "+x", "./entrypoint.sh"]
ENTRYPOINT [ "/bin/bash", "./entrypoint.sh" ]
Then i enter inside container using:
docker exec -it <containerId> bash
Expectation:
I expect edgeboxId accessible inside nodejs application running inside pm2 process as soon as the the container starts with my entrypoint.sh file.
Whats really happening:
edgeboxId appears undefined inside nodejs application but when i run the command pm2 restart ce-edgebox-application --update-env manually inside container then edgeboxId is accessible inside nodejs application.
Question:
How to make edgeboxId accessible inside nodejs as soon as the container starts with my entrypoint.sh file?
I have this command to start a Node.js webserver like this:
node --inspect=0.0.0.0:9229 --preserve-symlinks /app/api/dist/server.js | pino-pretty
I'm placing it into a Dockerfile as the CMD:
CMD ["node", "--inspect=0.0.0.0:9229", "--preserve-symlinks" ,"/app/api/dist/server.js", "|","pino-pretty"]
The service starts when calling docker run but the | is ignored so no logs are forwarded to pino-pretty.
What am I doing wrong here?
I could put the whole command into a start.sh or use CMD ["npm", "run", "start:prod"] but I want to understand the core problem.
I could put the whole command into a start.sh or use CMD ["npm", "run", "start:prod"] but I want to understand the core problem.
A pipe is a shell construct, e.g. a feature of /bin/sh, /bin/bash, and similar shells. When you define CMD with the json/exec syntax, you are explicitly telling docker to run the command without a shell. Therefore you need to either run the command in a script, call a shell explicitly, or run with the string/shell syntax to have docker execute the command with a shell:
CMD node --inspect=0.0.0.0:9229 --preserve-symlinks /app/api/dist/server.js | pino-pretty
I'm trying to deploy a Dockerized React App to Heroku, but keep getting the
"R10: Failed to bind to $PORT error on Heroku"
.
The dockerized app runs perfectly fine when i docker run it locally.
My docker file looks like the following:
FROM node:10.15.3
RUN mkdir -p /app
WORKDIR /app
COPY . .
ENV PATH /app/node_modules/.bin:$PATH
COPY package.json /app/package.json
RUN npm install --verbose
RUN npm install serve -g -silent
# start app
RUN npm run build
CMD ["serve", "-l", "tcp://0.0.0.0:${PORT}", "-s", "/app/build"]
I followed the online solution to change the "listening" port on serve to $PORT from Heroku. Now the application is served on Heroku's port according to logs, but still, get the
"Failed to bind to $PORT error"
.
Please help!
variable substitution does not happen in CMD that is why ${PORT} is consider as a text instead of consuming its value.
Unlike the shell form, the exec form does not invoke a command shell. This means that normal shell processing does not happen. For example, CMD [ "echo", "$HOME" ] will not do variable substitution on $HOME. If you want shell processing then either use the shell form or execute a shell directly, for example: CMD [ "sh", "-c", "echo $HOME" ]. When using the exec form and executing a shell directly, as in the case for the shell form, it is the shell that is doing the environment variable expansion, not docker.
docker-cmd
Change CMD to
CMD ["sh", "-c", "serve -l tcp://0.0.0.0:${PORT} -s /app/build"]
I have just installed dockers and installed node.
I am able to run a basic express site. My issue now is I can't stop it. Control-C is not doing anything.
Temporarily what I did to exit was:
Close the docker's terminal.
Open a new one.
Search for all docker containers that is running.
Then docker stop [container]
Is this the proper way?
As described here: github: docker-node best practice
You can add the --init flag to your docker run command.
docker run -it --init -p 3000:3000 --name nodetest mynodeimage
I don't know if this is too late. But the correct way to do this is to catch the SIGINT (interrupt signal in your javascript).
var process = require('process')
process.on('SIGINT', () => {
console.info("Interrupted")
process.exit(0)
})
This should do the trick when you press Ctrl+C
I came across this same problem today, and struggled to find an explanation/solution. I discovered (through trial and error) that this only occurs when the CMD in the Dockerfile is set to:
CMD [ "node", "server.js" ]
However, Ctrl+C works fine when the CMD is changed to:
CMD [ "npm", "start" ]
The npm start script in my package.json file is set to node server.js, so I have no idea why this change works, but hopefully this helps.
A docker run should have gave you back the prompt, avoiding the need for CTRL+C, or closing the docker terminal.
Once you log back in that terminal, a docker ps -a + docker stop should be enough to make your container exit (you still need to remove it before trying to launch it again)
If you just want to stop node without stopping the container, you could go inside the container and run:
$ ps aux | grep node #to obtain process ID (value in second column)
$ kill <process ID>
As a part of solution, you can open your package.js and add 3 new commands/scripts :
"scripts": {
"docker-build-and-run": "docker build -t image-dev-local . && docker run -p 3001:3001 --name container-dev-local image-dev-local",
"docker-stop-and-clear": "(docker stop container-dev-local || true) && (docker rm container-dev-local || true)",
"docker-run": "npm run docker-stop-and-clear && npm run docker-build-and-run"
}
and just simply run in the terminal :
npm run docker-run
to up your app on 3001 port in docker and have fun. Every next run will clear previous and build/run again.
To stop and delete it, just run :
npm run docker-stop-and-clear
docker stop <containerName/containerId>
docker kill --signal=SIGINT <containerName/containerId>
docker rm -f <containerName/containerId>
From what I can gather you need both -t and -i for Ctrl-C to work as expected. Command like this would be helpful i believe.
Simple example which i can think of this below
Case 1 to retain container:
$ ID=$(sudo docker run -t -d ubuntu /usr/bin/top -b)
$ sudo docker attach $ID
Control-C
$ sudo docker ps
Case 2 to terminate the container:
$ ID=$(sudo docker run -t -i -d ubuntu /usr/bin/top -b)
$ sudo docker attach $ID
Control-C
$ sudo docker ps
The solution is to use in the Dockerfile this command for starting the application
CMD ["/bin/sh", "-c", "node app.js"]
then we can listen in the app.js with
process.on('SIGTERM', () => {
console.log('SIGTERM received, shutting down...');
});
and we have to run the dockerfile with the --init flag
docker run --init -p 3000:3000 --name nodetest mynodeimage
or we can add in docker-compose beginning from version 3.7 the entry
init: true
to the desired service.
For the app to receive the signal you should use docker stop nodetest or docker-compose down. Shutting down with Ctrl+C does not send the SIGTERM signal.
Inside the node console, after running docker run -it node,
you can exit with the following:
Enter .exit
Press two times
ctrl+c
ctrl+d
If the node container is started in detached mode docker run -d node,
you can stop it with docker stop <CONTAINER_ID or CONTAINER_NAME>.
For example, assuming you want to kill the newest node container:
docker stop $(docker ps | grep node | awk 'NR == 1 { print $1}')
I build a Docker image with Node.js and pm2. I started the container with:
docker run -d --name test -p 22 myImage
Then I go inside the container with:
docker exec -it test /bin/bash
In the container, exec the command:
pm2 list
And it stuck here:
P.s.: My application works well in the Docker container, if I add CMD pm2 start app.js in the Dockerfile.
If your dockerfile CMD is a pm2 command, you have you include --no-daemon arg option so pm2 runs in the foreground and so your docker container continues to run.
An example Dockerfile CMD:
CMD ["pm2", "start", "app.js", "--no-daemon"]
Otherwise, without --no-daemon, pm2 launches as a background process and docker thinks the execution of the pm2 command is done running and stops.
See https://github.com/Unitech/PM2/issues/259
CMD ["pm2-docker", "pm2.yaml"]
This is the new approach.
Please do not use previous approaches.