


How to softly connect to the host directory in a docker container
As a technology for rapid deployment and management of applications, Docker has been widely used in development and production environments. When using Docker, we often need to map the host directory to the inside of the Docker container so that the container can read and write files on the host.
However, in some cases, we need to soft-connect a directory or file in the Docker container to a directory or file on the host machine. This is very useful in practical applications, such as using soft connections to share a code base between the host and the container, or allowing the container to access a certain hardware device on the host.
This article will introduce how to implement a soft connection to the host directory inside the Docker container.
- Preparation
In order to implement a soft connection to the host directory inside the Docker container, we need to first share the directory on the Docker host to the inside of the Docker container. Here we take the /data
directory of the shared host as an example.
First, create a directory /data
on the host, create a file test.txt
in the directory, and then write some test content in the file . Next, we need to map the host's /data
directory to a directory inside the Docker container when starting the Docker container, such as /container_data
.
Assume that we have started a Docker container named test
through the docker run
command and mapped the host's /data
directory Arrived in the /container_data
directory inside the container. Now we can check the /container_data
directory inside the Docker container to verify that the share has been set up correctly.
- Create a soft connection inside the Docker container
After completing the sharing settings, we can create a soft connection inside the Docker container and add a directory or file in the container Link to a directory or file on the host machine. Here we take the soft connection of /container_data/test.txt
in the container to /data/test.txt
on the host as an example.
Run the following command in the Docker container:
ln -s /container_data/test.txt /data/test.txt
This command will create a soft connection /data/test.txt
in the container and point it to /data/test.txt
on the host machine. We can verify whether the soft connection has been created correctly inside the Docker container:
ls -l /data/test.txt
This command will output the following:
lrwxrwxrwx 1 root root 24 Mar 17 10:00 /data/test.txt -> /container_data/test.txt
As you can see, the -> in the output result The ;
symbol indicates that /data/test.txt
is softly connected to /container_data/test.txt
.
- Test whether the soft link is working properly
After confirming that the soft link has been correctly created inside the Docker container, we can test whether the soft link is working correctly. It can be tested by reading and writing /container_data/test.txt
in the Docker container and reading and writing /data/test.txt
on the host.
First, run the following command inside the Docker container to redirect the contents of the test.txt
file to /container_data/test.txt
:
echo "test message in container" > /container_data/test.txt
Then, on the host machine, we can view the contents of the /data/test.txt
file to verify whether the soft link works successfully:
cat /data/test.txt
You can see, ## The content in #test.txt is the same as what is set inside the Docker container.
/data/test.txt file on the host:
echo "test message in host" >> /data/test.txtThen, we view it inside the Docker container again
/container_data/test.txt Contents of the file:
cat /container_data/test.txtYou can see that the newly added content has been correctly appended to the
test.txt file.
- Summary
The above is the detailed content of How to softly connect to the host directory in a docker container. For more information, please follow other related articles on the PHP Chinese website!

Hot AI Tools

Undress AI Tool
Undress images for free

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

Notepad++7.3.1
Easy-to-use and free code editor

SublimeText3 Chinese version
Chinese version, very easy to use

Zend Studio 13.0.1
Powerful PHP integrated development environment

Dreamweaver CS6
Visual web development tools

SublimeText3 Mac version
God-level code editing software (SublimeText3)

Hot Topics











A common way to create a Docker volume is to use the dockervolumecreate command and specify the volume name. The steps include: 1. Create a named volume using dockervolume-createmy-volume; 2. Mount the volume to the container through dockerrun-vmy-volume:/path/in/container; 3. Verify the volume using dockervolumels and clean useless volumes with dockervolumeprune. In addition, anonymous volume or binding mount can be selected. The former automatically generates an ID by Docker, and the latter maps the host directory directly to the container. Note that volumes are only valid locally, and external storage solutions are required across nodes.

Docker containers are a lightweight, portable way to package applications and their dependencies together to ensure applications run consistently in different environments. Running instances created based on images enable developers to quickly start programs through "templates". Run the dockerrun command commonly used in containers. The specific steps include: 1. Install Docker; 2. Get or build a mirror; 3. Use the command to start the container. Containers share host kernels, are lighter and faster to boot than virtual machines. Beginners recommend starting with the official image, using dockerps to view the running status, using dockerlogs to view the logs, and regularly cleaning resources to optimize performance.

There are three common ways to set environment variables in a Docker container: use the -e flag, define ENV instructions in a Dockerfile, or manage them through DockerCompose. 1. Adding the -e flag when using dockerrun can directly pass variables, which is suitable for temporary testing or CI/CD integration; 2. Using ENV in Dockerfile to set default values, which is suitable for fixed variables that are not often changed, but is not suitable for distinguishing different environment configurations; 3. DockerCompose can define variables through environment blocks or .env files, which is more conducive to development collaboration and configuration separation, and supports variable replacement. Choose the right method according to project needs or use multiple methods in combination

EXPOSE is used in Dockerfile to declare the network port the container will listen for at runtime, but it will not be published automatically to the host. Its core role is to provide documentation and configuration tips to help developers and tools understand the ports used by the application. To make the port accessible from the outside, you still need to use the -p parameter to map when running the container, for example: dockerrun-p8080:80my-web-app. The main reasons for using EXPOSE include improving clarity, supporting tool integration, and following best practices. Containers can directly access each other's exposed ports in the same custom network, but to access them on the host, the ports must be published explicitly. A common error is that you forget to map the port when running the container, causing the service to fail.

The main difference between Docker and traditional virtualization lies in the processing and resource usage of the operating system layer. 1. Docker containers share the host OS kernel, which is lighter, faster startup, and more resource efficiency; 2. Each instance of a traditional VM runs a full OS, occupying more space and resources; 3. The container usually starts in a few seconds, and the VM may take several minutes; 4. The container depends on namespace and cgroups to achieve isolation, while the VM obtains stronger isolation through hypervisor simulation hardware; 5. Docker has better portability, ensuring that applications run consistently in different environments, suitable for microservices and cloud environment deployment.

To back up and restore Docker volumes, you need to use temporary containers in conjunction with tar tools. 1. During backup, run a temporary container that mounts the target volume, use the tar command to package the data and save it to the host; 2. During recovery, copy the backup file to the container that mounts the volume and decompress it, pay attention to path matching and possible overwriting of data; 3. Multiple volumes can be written to automatically cycle through each volume; 4. It is recommended to operate when the container is stopped to ensure data consistency, and regularly test the recovery process to verify the backup validity.

To view Docker container logs, use the dockerlogs command mainly. 1. Use dockerlogs [container name or ID] to view the log directly; 2. Add the -f parameter to track the log output in real time; 3. Use --timestamps or -t to display timestamps; 4. Use --since and --until to filter the logs by time range; 5. If the container has no shell, you can still access the stdout/stderr logs through dockerlogs, or mount the volume to access custom log files; 6. You can check the log driver used by the container through dockerinspect. If it is not the default JSON-file driver, you need to check the corresponding external system.

DockerworkswithJavabypackagingapplicationsanddependenciesintoportablecontainers.TorunaJavaappinDocker,createaDockerfilethatdefinesthebuildsteps.AbasicDockerfileusesaJavabaseimagelikeopenjdk:17-jdk-slim,setsaworkingdirectory,copiestheJARfile,andspecif
