Shell scripting is a fundamental skill for automating tasks on Unix-like systems. When using Docker, you might need to execute these shell scripts within a container and pass arguments to them. This article provides a detailed guide on passing arguments to shell scripts in a Docker container using the docker run command.

Understanding Docker and Shell Scripts

Docker is a platform that uses containerization to execute applications within isolated environments. Shell scripts are files containing a sequence of commands for the shell to execute.

Why Pass Arguments?

Passing arguments to shell scripts allows for dynamic execution of the script with varying inputs without the need to modify the script itself. This ability enhances automation and flexibility, crucial in environments like CI/CD pipelines.

Basic Structure

To pass arguments to a shell script within a Docker container, you usually follow this pattern:

docker run [OPTIONS] IMAGE [COMMAND] [ARG...]

Here, [COMMAND] often refers to the shell or script you wish to execute, and [ARG...] represents the arguments you want to pass.

Steps to Pass Arguments to Shell Scripts in Docker

Step 1: Create a Docker Image

1. Write the Shell Script
   Create a shell script that can accept arguments. For example, create a hello.sh script:

   #!/bin/sh
   echo "Hello, $1"

1. Create a Dockerfile
   Build a Docker image that contains this script:

1   FROM alpine:latest
2   COPY hello.sh /hello.sh
3   RUN chmod +x /hello.sh
4   CMD ["/hello.sh"]

This Dockerfile uses the Alpine Linux base image, copies the hello.sh script to the container, makes it executable, and sets it as the default command.

Step 2: Build the Docker Image

Execute the following command to build the Docker image, naming it helloscript:

docker build -t helloscript .

Step 3: Run the Docker Container

Execute the Docker container with arguments:

docker run helloscript World

In this instance, the script will output Hello, World.

Handling Multiple Arguments

Modify the hello.sh script to handle multiple arguments:

#!/bin/sh
echo "Hello, $1 $2 $3"

Run it as follows:

docker run helloscript Docker Enthusiast

This outputs: Hello, Docker Enthusiast.

Using Entrypoint with Arguments

Docker provides the ENTRYPOINT instruction in the Dockerfile, which can be combined with CMD to specify both the entrypoint script and default arguments. This combination allows more structured argument handling.

Example of a Dockerfile with ENTRYPOINT:

1FROM alpine:latest
2COPY hello.sh /hello.sh
3RUN chmod +x /hello.sh
4ENTRYPOINT ["/hello.sh"]

You can then run the container with:

docker run helloscript Alex

The script now runs directly with the argument provided.

Summary Table

Advanced Topics

Using Environment Variables

For more complex argument handling, consider using environment variables. You can pass environment variables using -e flag or --env-file option.

docker run -e NAME=Sunny helloscript

Argument Introspection

In more sophisticated scripts, you may want to introspect provided arguments. Consider updating the script to loop through all arguments:

1#!/bin/sh
2echo "Script arguments:"
3for arg in "$@"
4do
5    echo $arg
6done

Run it with multiple arguments to see all entries:

docker run helloscript one two three

Conclusion

Passing arguments to shell scripts through Docker is an essential technique for writing flexible and reusable automation scripts. By correctly structuring your Dockerfile and understanding the docker run command's syntax, you can effectively pass parameters to your scripts, enhancing their utility and adaptability in various environments.