{"id":1321,"date":"2024-07-23T12:20:37","date_gmt":"2024-07-23T12:20:37","guid":{"rendered":"https:\/\/dockerpros.com\/?post_type=glossary&p=1321"},"modified":"2024-07-23T12:23:26","modified_gmt":"2024-07-23T12:23:26","slug":"dockerfile-stopsignal","status":"publish","type":"glossary","link":"https:\/\/dockerpros.com\/fr\/wiki\/dockerfile-stopsignal\/","title":{"rendered":"Dockerfile STOPSIGNAL"},"content":{"rendered":"

Understanding the Dockerfile STOPSIGNAL Instruction<\/h1>\n

The STOPSIGNAL<\/code> instruction in a Dockerfile<\/a><\/span>A Dockerfile is a script containing a series of instructions to automate the creation of Docker images. It specifies the base image, application dependencies, and configuration, facilitating consistent deployment across environments. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> specifies the system signal that will be sent to the main process in the container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> when a docker stop<\/code> command is issued. This instruction is crucial for defining how a container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> gracefully shuts down, allowing for proper cleanup of resources, data flushing, and termination of child processes. Understanding the STOPSIGNAL<\/code> directive enhances the management of Docker containers, especially in production environments where stability and data integrity are paramount.<\/p>\n

The Importance of Signal Handling in Containers<\/h2>\n

Signals in Unix-like operating systems are an essential mechanism for inter-process communication. They allow processes to receive notifications to perform specific actions, such as terminating gracefully or reloading configuration files. In the context of Docker, understanding how to handle signals effectively can determine the stability and reliability of applications running within containers.<\/p>\n

When a Docker container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> is stopped, Docker uses a default signal (SIGTERM<\/code>) to signal the main process within the container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>. However, the way an application responds to this signal can vary widely. By default, many applications may terminate immediately upon receiving SIGTERM<\/code>, leading to potential data loss or corruption. The STOPSIGNAL<\/code> instruction allows developers to customize this behavior, ensuring that applications have the opportunity to complete ongoing tasks before shutting down.<\/p>\n

Syntax and Usage<\/h2>\n

The syntax for the STOPSIGNAL<\/code> instruction in a Dockerfile<\/a><\/span>A Dockerfile is a script containing a series of instructions to automate the creation of Docker images. It specifies the base image, application dependencies, and configuration, facilitating consistent deployment across environments. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> is straightforward:<\/p>\n

STOPSIGNAL <\/code><\/pre>\n
Where ` can be any valid signal name such as<\/code>SIGTERM,<\/code>SIGINT, or a generic number representing a signal. For example, to set<\/code>SIGQUIT` as the stop signal, you would write:<\/p>\n
STOPSIGNAL SIGQUIT<\/code><\/pre>\n
It is worth noting that the signal can be specified in either its symbolic name (like SIGTERM<\/code>) or its numeric representation (like 15<\/code>, the operating system default for SIGTERM<\/code>). The following example illustrates both usages:<\/p>\n
STOPSIGNAL SIGTERM\n# or\nSTOPSIGNAL 15<\/code><\/pre>\n
Default Behavior Without STOPSIGNAL<\/h2>\n
If the STOPSIGNAL<\/code> instruction is omitted from a Dockerfile<\/a><\/span>A Dockerfile is a script containing a series of instructions to automate the creation of Docker images. It specifies the base image, application dependencies, and configuration, facilitating consistent deployment across environments. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>, Docker defaults to sending SIGTERM<\/code> to the PID 1 process in the container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> when the docker stop<\/code> command is executed. This can be problematic for some applications that are not designed to handle SIGTERM<\/code> properly. Consequently, they may not terminate gracefully, leading to resource leaks, incomplete transactions, or corrupted state.<\/p>\n
Example of Default Behavior<\/h3>\n
Consider a simple application that does not handle SIGTERM<\/code>. When the docker stop<\/code> command is issued:<\/p>\n
docker stop my_container<\/code><\/pre>\n
Docker sends SIGTERM<\/code> to the main process. If the application does not implement any signal handling logic, it terminates immediately, potentially leading to data loss.<\/p>\n
Implementing STOPSIGNAL for Graceful Shutdown<\/h2>\n
To implement the STOPSIGNAL<\/code> instruction effectively, the application within the container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> should have signal handling mechanisms to manage shutdown procedures. Below is a step-by-step guide on how to implement STOPSIGNAL<\/code> for a Node<\/a><\/span>Node, or Node.js, is a JavaScript runtime built on Chrome's V8 engine, enabling server-side scripting. It allows developers to build scalable network applications using asynchronous, event-driven architecture. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>.js application.<\/p>\n
Step 1: Create a Simple Node.js Application<\/h3>\n
Let’s create a basic Express application that listens for HTTP requests and gracefully handles shutdown:<\/p>\n
\/\/ app.js\nconst express = require('express');\nconst app = express();\nconst PORT<\/a><\/span>A PORT is a communication endpoint in a computer network, defined by a numerical identifier. It facilitates the routing of data to specific applications, enhancing system functionality and security. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> = process.env.PORT || 3000;\n\napp.get('\/', (req, res) => {\n    res.send('Hello, World!');\n});\n\n\/\/ Signal handling\nconst server = app.listen(PORT<\/a><\/span>A PORT is a communication endpoint in a computer network, defined by a numerical identifier. It facilitates the routing of data to specific applications, enhancing system functionality and security. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span>, () => {\n    console.log(`Server is running on port<\/a><\/span>A PORT is a communication endpoint in a computer network, defined by a numerical identifier. It facilitates the routing of data to specific applications, enhancing system functionality and security. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> ${PORT}`);\n});\n\n\/\/ Graceful shutdown\nconst shutdown = () => {\n    console.log('Received shutdown signal, closing server...');\n    server.close(() => {\n        console.log('Server closed');\n        process.exit(0);\n    });\n};\n\nprocess.on('SIGTERM', shutdown);\nprocess.on('SIGINT', shutdown);<\/code><\/pre>\n
Step 2: Write the Dockerfile<\/h3>\n
Next, create a Dockerfile<\/a><\/span>A Dockerfile is a script containing a series of instructions to automate the creation of Docker images. It specifies the base image, application dependencies, and configuration, facilitating consistent deployment across environments. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> that includes the STOPSIGNAL<\/code> instruction:<\/p>\n
# Use a Node.js base image\nFROM node:14\n\n# Set the working directory\nWORKDIR \/usr\/src\/app\n\n# Copy application files\nCOPY package*.json .\/\nRUN npm install\nCOPY . .\n\n# Specify the stop signal\nSTOPSIGNAL SIGTERM\n\n# Expose the port\nEXPOSE 3000\n\n# Command to run the application\nCMD [\"node\", \"app.js\"]<\/code><\/pre>\n
Step 3: Build and Run the Container<\/h3>\n
Build and run<\/a><\/span>\"RUN\" refers to a command in various programming languages and operating systems to execute a specified program or script. It initiates processes, providing a controlled environment for task execution. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> the Docker container<\/a><\/span>Containers are lightweight, portable units that encapsulate software and its dependencies, enabling consistent execution across different environments. They leverage OS-level virtualization for efficiency. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> using the following commands:<\/p>\n
docker build -t my-node-app .\ndocker run<\/a><\/span>\"RUN\" refers to a command in various programming languages and operating systems to execute a specified program or script. It initiates processes, providing a controlled environment for task execution. More \u00bb<\/a><\/span><\/span><\/span><\/span><\/span> --name my-node-app -p 3000:3000 my-node-app<\/code><\/pre>\n
Step 4: Test the Graceful Shutdown<\/h3>\n
Now test the graceful shutdown by executing:<\/p>\n
docker stop my-node-app<\/code><\/pre>\n
The output should indicate that the server is closing gracefully, thanks to the signal handling implemented in the application.<\/p>\n
Customizing the Stop Signal<\/h2>\n
While SIGTERM<\/code> is the default and often the most appropriate choice, there are scenarios where you might want to use different signals depending on your application’s specific needs.<\/p>\n
Using SIGKILL for Immediate Termination<\/h3>\n
In some cases, you may wish to use SIGKILL<\/code> as the stop signal. This would be useful for applications that do not need to perform any cleanup:<\/p>\n
STOPSIGNAL SIGKILL<\/code><\/pre>\n
However, using SIGKILL<\/code> prevents the application from executing any shutdown logic, which can lead to data inconsistency or other issues. It should be used with caution and only when absolutely necessary.<\/p>\n
Choosing Between Signals<\/h3>\n
The choice of stop signal should be based on how the application is designed to handle shutdowns:<\/p>\n