Skip to main content

[SOLVED] How to run shell script on host from docker container? - docker

[SOLVED] How to Execute Shell Scripts on Host from a Docker Container

In this article, we will look at ways to run shell scripts on the host system from a Docker container. This is really helpful for developers and system admins. They want to manage host resources or automate tasks from inside a container. We will talk about different solutions that let us connect the Docker container and the host system. This helps us work better and be more productive.

Here is a quick list of the solutions we will talk about:

  • Solution 1: Using Docker Volumes to Access Host Scripts
  • Solution 2: Running Host Commands with Docker’s docker exec
  • Solution 3: Using host.docker.internal for Host Communication
  • Solution 4: Running Scripts with SSH from Docker Container
  • Solution 5: Custom Entrypoint Scripts for Host Interaction
  • Solution 6: Using Docker Compose for Host Script Execution

For more useful info, we can check out our articles on how to manage Docker containers and using Docker volumes. Now let’s look at each solution and see how to run shell scripts on the host from a Docker container.

Solution 1 - Using Docker Volumes to Access Host Scripts

One simple way to run a shell script from your host in a Docker container is using Docker volumes. This method helps us share files and folders between our host machine and the container. By mounting a folder or specific files from the host into the container, we can run scripts easily.

Step-by-Step Guide

  1. Create the Shell Script on the Host: First, we need to create a shell script on our host machine. For example, we can make a file named script.sh:

    #!/bin/bash
echo "Hello from the host script!"

    We should give it permission to run:

    chmod +x script.sh

  2. Run the Docker Container with Volume Mounting: Use the -v option in the docker run command to mount the folder that has our script. For example, if our script is in /path/to/your/script.sh, we run:

    docker run --rm -v /path/to/your:/scripts your_docker_image_name bash /scripts/script.sh

    In this command:

    • --rm makes sure the container is deleted after it stops.
    • -v /path/to/your:/scripts mounts the host folder to /scripts in the container.
    • your_docker_image_name should be replaced with the name of our Docker image.
    • bash /scripts/script.sh runs the shell script inside the container.

Example

If we have a Docker image named ubuntu, we can run the script like this:

docker run --rm -v $(pwd):/scripts ubuntu bash /scripts/script.sh

This command will show:

Hello from the host script!

Notes

  • Make sure the path to our script is correct and we can access it.
  • We can find more info on using Docker volumes in this Docker volumes documentation.

Using Docker volumes is easy and helps us run scripts from our host inside a Docker container. This way, we can interact smoothly between the container and the host system.

Solution 2 - Running Host Commands with Docker’s docker exec

We can run shell scripts on the host from a Docker container by using the docker exec command. This command helps us execute commands in a running container. It can interact with the host based on permissions and settings.

Steps to Run Host Commands

  1. Find the Container: First, we need to know the name or ID of the running container. We can find this by running:

    docker ps

  2. Run the Command with docker exec: After we have the container name or ID, we can run commands on the host like this:

    docker exec <container_name_or_id> <command>

  3. Use a Shell Script: If we have a shell script on the host that we want to run, we can do it like this:

    docker exec <container_name_or_id> /bin/sh -c "sh /path/to/your/script.sh"

Example

Let’s say we have a shell script at /home/user/myscript.sh on the host, and our container is called my_container. We can run it from inside the container like this:

docker exec my_container /bin/sh -c "sh /home/user/myscript.sh"

Important Things to Remember

  • Permissions: We must make sure that the user who runs the Docker container can execute the script on the host. If the script needs higher permissions, we should think about running the container in privileged mode. But be careful, this can have security issues.
  • Environment Variables: If our script needs some environment variables, we may need to pass them in the docker exec command.

Use Case Examples

  • Automated Deployments: In CI/CD, we might want to run deployment scripts on the host.
  • Monitoring Scripts: We can run monitoring or maintenance scripts on the host from a containerized application.

More Resources

For more details on using Docker containers and running commands, we can check this guide on Docker commands. If we want to manage many containers and how they work together, we can look at Docker Compose for easier management.

Solution 3 - Using host.docker.internal for Host Communication

We can run a shell script on the host from a Docker container by using the special DNS name host.docker.internal. This lets our Docker container access services on the host machine like they are part of the container’s network.

Steps to Use host.docker.internal

  1. Check Your Docker Version: This feature works in Docker for Windows and Docker for Mac. If we are using Docker on Linux, host.docker.internal may not be there by default.

  2. Run Your Docker Container: When we start our container, we can use the host.docker.internal address to connect with services on the host. For example, if we want to run a script at /path/to/your_script.sh on the host, we can use this command:

    docker run --rm -it your_image_name /bin/sh -c "curl http://host.docker.internal:port/your_script.sh | sh"

    Just change port to the right port number where our service runs on the host.

  3. Accessing Localhost Services: We can also use host.docker.internal to run commands or get services on localhost. For example, if we have a web server on the host, we can access it from the container like this:

    curl http://host.docker.internal:80

  4. Running Shell Scripts: If we want to run a script directly, we need to make sure it is executable and can be accessed. We can run it using SSH if we set up SSH access:

    ssh user@host.docker.internal 'bash /path/to/your_script.sh'

  5. Networking Considerations: We must ensure that our firewall settings let the container and host talk to each other. If we use Docker on Linux, we may need to set up routing rules for this connection.

Example Use Case

Let’s say we have a script called run.sh on our host that we want to run from a Docker container:

  • On Host:

    #!/bin/bash
echo "Running script on host!"

  • Run Docker Container:

    docker run --rm -it --network host your_image_name /bin/sh -c "curl http://host.docker.internal:8080/run.sh | sh"

In this example, we think that we have a local web server giving the script at port 8080.

By using host.docker.internal, we can make the connection between our Docker container and host easy. This helps us run scripts and access resources smoothly. For more information on managing Docker environments, we can check this guide.

Solution 4 - Running Scripts with SSH from Docker Container

We can run a shell script on the host machine from a Docker container using SSH (Secure Shell). This way, we can execute commands on the host without going into its filesystem from the container. Let’s see how we can set this up.

Prerequisites

  1. SSH Server on Host: We need to make sure that the SSH server is installed and running on our host machine. We can check this by running:

    systemctl status ssh

  2. SSH Keys: We need to set up SSH keys for password-less login from the Docker container to the host. This helps us to avoid entering a password each time we run a command.

  3. Docker Container with SSH Client: Our Docker container must have an SSH client installed. Most official images have it, but we can install it like this:

    RUN apt-get update && apt-get install -y openssh-client

Steps to Execute Host Scripts via SSH

  1. Generate SSH Keys: If we do not have an SSH key pair, we can create one in our container:

    ssh-keygen -t rsa -b 2048

  2. Copy the Public Key to Host: We use ssh-copy-id to copy our public key to the host machine:

    ssh-copy-id user@host_ip

    Here, replace user with our username and host_ip with the IP address of the host machine.

  3. Run the Script from the Container: When SSH is ready, we can run scripts on the host by using:

    ssh user@host_ip 'bash -s' < /path/to/your/script.sh

    This command sends the script from our container to run on the host.

Example

Let’s say we have a script called backup.sh on our host that we want to run from the Docker container. The command would look like this:

ssh user@host_ip 'bash -s' < /path/to/backup.sh

Additional Considerations

  • Firewall Settings: We should check that the host’s firewall allows incoming SSH connections, usually on port 22.

  • Docker Networking: If we run our Docker container with a bridge network, we may need to use the host’s IP address to connect via SSH. We can find our host’s IP with:

    ip addr show

  • Testing the Connection: Before running scripts, we can test our SSH connection from the container to make sure everything works:

    ssh user@host_ip 'echo "SSH connection successful!"'

Using SSH to run scripts on the host from our Docker container is a useful way to execute commands safely and flexibly. This method works well for automation tasks and keeps the host and container environments separate. For more details on Docker networking and managing containers, we can check Docker Networking and Docker Working with Containers.

Solution 5 - Custom Entrypoint Scripts for Host Interaction

We can run shell scripts on the host from a Docker container by using custom entrypoint scripts. This way, we can include the logic to run host commands right in the entrypoint script of our Docker container. It helps us to run host tasks easily when the container starts.

Creating a Custom Entrypoint Script

  1. Create the Shell Script: First, we will create a shell script on the host that we want to run. For example, let’s make a script called run_host_script.sh.

    #!/bin/bash
echo "This script is running on the host!"

    We need to make sure this script can be executed:

    chmod +x run_host_script.sh

  2. Dockerfile Configuration: In our Dockerfile, we have to set a custom entrypoint. Here is how to do it:

    FROM ubuntu:latest

# Copy the entrypoint script into the container
COPY entrypoint.sh /usr/local/bin/entrypoint.sh

# Make the entrypoint script executable
RUN chmod +x /usr/local/bin/entrypoint.sh

# Set the entrypoint
ENTRYPOINT ["/usr/local/bin/entrypoint.sh"]

  3. Writing the Entrypoint Script: Now, we create the entrypoint.sh script that will run the host script. This script will use a mounted volume to access the host script.

    #!/bin/bash

# Run the script on the host
/mnt/host/run_host_script.sh

# Continue with the rest of the container's commands
exec "$@"

  4. Running the Docker Container: When we run the Docker container, we must mount the directory with run_host_script.sh to a path inside the container. For example:

    docker run --rm -v /path/to/host/scripts:/mnt/host your-image-name

This method makes sure that when the container starts, it runs run_host_script.sh from the /path/to/host/scripts folder on the host.

Considerations

  • Permissions: We need to make sure the user running the Docker container can execute the host script.
  • Volume Mounting: The host script must be available through a volume mount. If not, the entrypoint script will not find it.
  • Environment Variables: If our host script needs environment variables, we can pass them when starting the container using the -e flag.

Using custom entrypoint scripts helps us to run shell scripts on the host from a Docker container. It also gives us the freedom to add more logic or checks before running the host commands. For more information on using Docker well, we can check out how to run Docker from the host.

Solution 6 - Using Docker Compose for Running Host Scripts

We can use Docker Compose to manage multi-container Docker apps. It also helps us run shell scripts on the host from a Docker container. By setting up our docker-compose.yml file right, we can link folders from the host to our container. This way, the container can run scripts that are on the host.

Step-by-Step Guide

  1. Create Your Shell Script on the Host:
    First, we need to make the shell script on our host machine. Let’s say we create a script called run_script.sh:

    #!/bin/bash
echo "Running script on host"

    Next, we have to give it permission to run:

    chmod +x run_script.sh

  2. Define Your Docker Compose Configuration:
    Now, we open our docker-compose.yml file. Here, we will link the host folder that has our script to the container. Here is an example setup:

    version: "3.8"

services:
  my_service:
    image: my_docker_image
    volumes:
      - ./path/to/your/scripts:/scripts
    entrypoint: ["/bin/sh", "-c", "/scripts/run_script.sh"]

    In this setup:

    • my_service is the name of our service.
    • my_docker_image is the Docker image we are using.
    • The volumes part links the host folder ./path/to/your/scripts to /scripts inside the container.
    • The entrypoint runs the shell script from /scripts/run_script.sh when the container starts.

  3. Run Docker Compose:
    We can run this command in the folder where our docker-compose.yml file is:

    docker-compose up

    This command starts the container. The shell script on the host runs inside the container.

Notes and Considerations

  • We need to check that the path to our script in the volumes part is correct and can be reached from the folder where we run docker-compose up.
  • The shell script can have any commands we want to run on the host. But we should make sure they work in the container’s environment.
  • If we want to run more scripts, we can change the entrypoint to call each script as needed.
  • For more advanced setups, we can look at the Docker Compose documentation for tips on service connections and networking.

By using Docker Compose, we can make it easier to run host scripts from our Docker containers. This helps improve our development and deployment processes.

Conclusion

In this article, we looked at different ways to run shell scripts on the host from a Docker container. We found solutions like using Docker volumes, running commands with docker exec, and using host.docker.internal. These methods give us more choices and make things faster. They also help us to communicate better between our Docker container and the host system.

If you want to learn more, we can check our guides on Docker volumes and Docker Compose.

Labels:

Comments

Post a Comment