Shulou(Shulou.com)05/31 Report--

This article mainly explains "how to create a local image in Docker". The content in the article is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn how to create a local image in Docker.

The image is the basis of the container operation, and the container is the shape after the image operation. The two are closely related and different.

1. The concept of mirror image

An image is a read-only file that contains the environment and code necessary for the program to run. It uses a hierarchical file system to add each change to the original read-only file in the form of a read-write layer.

1.1 Images and containers

If the container is understood as a virtual environment in which the program runs, then the image is the template used to build the environment. Through the same image, we can construct many containers that are independent of each other but run in the same environment.

The bottom layer of the image must be an image called the boot file (bootfs), and users will not deal directly with this layer. The upper image of bootfs is called root image (rootfs), which is usually an operating system, such as Ubuntu, Debina, CentOS and so on.

2. Management of local images

2.1 View

Docker imagesdocker images ub* / / use wildcards to view the results similar to the following table REPOSITORYTAGIMAGE_IDCREATEDVIRTUAL SIZEcentoslaster10009deww345 hours ago199MB

REPOSITORY is the name of the repository, which is generally used to store images of the same type, and its name is specified by the creator.

Command rules:

1. [namespace\ ubuntu]: consists of the namespace and the actual repository name, separated by "\". If you want to submit to the unofficial warehouse name of DOcker Hub, you must follow this rule.

2. [ubuntu]: only the repository name, which belongs to the top-level namespace, can only be used for official images. This name can also be used locally, but it cannot be distributed to DOcker Hub for sharing.

3. [dl.dockerpool.com:5000\ ubuntu:12.04]: how to specify the URL path. It is generally used on self-built Hub or third-party Hub. Dl.dockerpool.com:5000 is the hostname and port of the third-party Hub.

TAG is used to distinguish different images in the same repository. If not specified, the default is laster

IMAGE_ID each mirror has a 64-bit HashID of string type, which, like the container ID, is used to uniquely identify an image. Generally, the first part only needs to uniquely identify an image on the local machine, which is similar to the CommitID rule of Git.

Time when the CREATED image was created.

The virtual size occupied by the VIRTUAL SIZE image, which contains the size of all shared files.

2.2 download

When the docker run command runs an image, it will first find the image locally. If it does not exist locally, it will continue to search Docker Hub for qualified images and download them to run.

Docker pull ubuntu:13.1013.10: Pulling from library/ubuntu / / 6599cadaf950: Pull complete 23eda618d451: Pull complete f0be3084efe9: Pull complete 52de432f084b: Pull complete a3ed95caeb02: Pull complete Digest: sha256:15b79a6654811c8d992ebacdfbd5152fcf3d165e374e264076aa435214a947a3Status: Downloaded newer image for ubuntu:13.10docker search wordpress / / Docker Hub search for images that meet the criteria will show the name (NAME), description (DESCRIPTION), STARS (the higher the image indicates better quality), whether it is an official image (OFFICIAL), Whether automatic build (AUTOMATED) is used

Sometimes the running image is not local and will be obtained from Docker Hub. You can download it to the local image in advance through the docker pull command, and then use the docker run command.

Docker pull ubuntu

2.3 Delete

If the deleted image is dependent on the container, it still depends on the image even if the container has been stopped. You cannot delete the image directly here. If you must delete it, you can use the-f parameter. However, for security reasons, it is recommended to stop the container first, delete the container and then delete the image.

Docker rmi image ID or name / / has one more i docker rmi-f image ID or name / / force delete image than the delete container command

3. Create a local image

There are three ways to create a local image:

1. Export the image to a tar file, and then import the image to create a new image. (this approach is described in Docker development practice notes-import and export of a container.)

2. Use the commit command to save the changes to the basic image and create a new image.

After running the mirror container, make modifications to the container and then use commit to commit and create it.

Docker run-I-t ubuntu modifies the container, such as installing software, modifying configuration, and so on. Docker commit-m = "Message"-if the container ID myDOcker/redis:v1 run by author= "LIU" needs to modify the above image, enter the container to update and then use the above command to submit a new version of the image. Docker commit-m = "Message"-- Container ID myDOcker/redis:v2 under which author= "LIU" runs

3. Use Dockerfile file to create an image (recommended)

Dockerfile is used to create a custom image, including user-specified software dependencies, etc.

The following is an example of a DOckerfile file, which simply introduces the syntax without any practical significance.

# version: 1.0 specifies the parent image to be extended. Except for comments, the file must begin with a FROM instruction FROM ubuntu:latest # author information MAINtAINER jiuwu "jiuwu@qq.com" # set root user as the executor of subsequent commands USET root # execute operation RUN apt-age updateRUN apt-get install-y nginx# use & & splicing command RUN touch test.txt & & echo "abc" > > abc.txt# external exposure port EXPOSE 80 8080 103 add file the first is the source file The second is the target path in the container to be added ADD abc.txt / opt/# add file ADD / webapp / opt/webapp# add network file ADD https://www.baidu.com/logo.jpg / opt/# setting environment variable ENV WEBAPP_PORT=9000# setting working directory WORKDIR / opt/# setting startup command can only appear once, the later will override the previous ENTRYPOINT ["ls"] # set startup parameters, can only appear once The following will overwrite the previous CMD ["- a", "- l"] # set the volume VOLUME ["/ data", "/ var/www"] # set the trigger operation of the child image (when an image is the parent image, the following actions will be performed) ONBUILD ADD. / app/srcONBUILD RUN echo "onbuild excuted" > > onbuild.txt

The following is a detailed description of the above instructions:

Instructions are not case sensitive. However, the naming convention is all uppercase.

All Dockerfile must start with the FROM command. The FROM command specifies the base image on which the image is created, and the following commands are based on this base image. (note: some commands for CentOS and Ubuntu are different). The FROM command can be used multiple times, indicating that multiple mirrors are created. The specific syntax is as follows:

FROM

1. MAINTAINER: set the author of the image. The syntax is as follows:

MAINTAINER

2. RUN: a command executed in the environment of shell or exec. The RUN instruction adds a new layer to the newly created image, and the result of the submission is used in the next instruction of Dockerfile. The syntax is as follows:

RUN "command" RUN apt-get update / / this form uses the command RUN ["apt-get", "update"] / / executed in the / bin/sh environment to execute multiple commands directly using the system call exec. You can execute RUN apt-get update & & apt-get install nginx with & & connection.

Note here that because a RUN adds a new layer, all best practices are to reduce the number of RUN times and merge as many operations as possible into the RUN at a time.

3. ADD: copy file instructions. It has two parameters and. Destination is the path within the container. The source can be a URL or a file in the startup configuration context. The syntax is as follows:

ADD "src"destination"

If the source file is a compressed file in the form of zip or tar on the host, Docker first unzips it, then adds the file to the location specified by the mirror, and does not extract it if it is a network compressed file specified by URL.

4. CMD: provides commands that are executed by default when the container starts. Dockerfile allows you to use the CMD instruction only once. The use of multiple CMD cancels out all previous instructions, and only the last instruction takes effect. There are three forms of CMD:

CMD ["executable", "param1", "param2"] CMD ["param1", "param2"] CMD command param1 param2

5. EXPOSE: specify the port on which the container listens at run time. The syntax is as follows:

EXPOSE; / / multiple ports are separated by spaces EXPOSE 80 8080 9000

When running the container, the port specified in the EXPOSE can be mapped to another random port on the host through the parameter-P (uppercase), and other containers or hosts can communicate with this container through the mapped port. At the same time, we can also set the ports not listed in EXPOSE in DOckerfile to public with the-p (lowercase) parameter.

6. ENTRYPOINT: configure the container with an executable command, which means that a specific application can be set as the default each time the container is created using an image. It also means that the image can only run the specified application each time it is called. Just like CMD,Docker allows only one ENTRYPOINT, multiple ENTRYPOINT cancels out all previous instructions and executes only the last ENTRYPOINT instruction. The syntax is as follows:

ENTRYPOINT ["executable", "param1", "param2"] ENTRYPOINT command param1 param2

7. WORKDIR: specify the working directory for the RUN, CMD, and ENTRYPOINT commands. The syntax is as follows:

WORKDIR / path/to/workdir

8. ENV: sets the environment variable. They use key-value pairs to increase the flexibility of running programs. The syntax is as follows:

ENV

You can set or modify environment variables with the-e parameter when running the container:

Docker run-e WEBAPP_PORT=8000-e WEBAPP_HOST=www.test.com....

9. USER: set a UID when the image is running. The syntax is as follows:

USER / / for example: USER root

10. VOLUME: authorizes access to directories from within the container to the host. The syntax is as follows:

VOLUME ["/ data"]

This mount is usually specified when the container is running, because it is associated with the host, so it is not convenient to share Dockerfile. Multiple containers can share data through the same mount point. Even if one of the containers has stopped, the mount point can still be accessed. Only when all the container references of the mount point disappear, the mount point will be deleted automatically.

11. ONBUILD: the specified command is not executed when the mirror is built, but in its child mirror.

The commands in ONBUILD are executed when the child image of the current mirror is built. You can pass the ONBUILD command as the Dockerfile of the parent image to the Dockerfile of the child mirror.

During the construction of the child image, Docker executes the instructions passed by the parent image through the ONBUILD before executing any instructions in the Dockerfile.

The ONBUILD directive is useful when building a new image from a given image. For example, you might use ONBUILD in a language stack mirror that is used to build arbitrary software written by users in the corresponding language in Dockerfile, just like the ONBUILD variant of Ruby

Images built using ONBUILD apply a separate tag, such as ruby:1.9-onbuild or ruby:2.0-onbuild.

Be careful when using ADD or COPY in ONBUILD. If the corresponding resource is missing in the new build context, the "onbuild" image will fail disastrously. Adding a separate tag that allows the author of Dockerfile to make a choice will help alleviate the situation.

Finally, I will highlight the CMD and ENTRYPOINT commands:

Both commands are used to specify the commands that run by default when the container starts.

Suppose that the ENTRYPOINT we specify looks like this:

ENTRYPOINT ["ls", "- l"]

And build an image named jiuwu/newImage, then the running result of docker run jiuwu/newImage is the same as that of docker run ubuntu ls-l, and that of docker run jiuwu/newImage-an is the same as docker run ubuntu ls-l-a.

Otherwise, you will find that the difference between ENTRYPOINT and CMD is that the parameters added after the image name when running the container are concatenated for ENTRYPOINT and overwritten for CMD. We can use-- entrypoint when running the container to override the specified in Dockerfile:

Docker run-entrypoint echo jiuwu/newImage "hello docker"

Output is: hello docker

Usually the wind will use ENTRYPOINT and CMD together. ENTRYPOINT is used to specify the commands that need to be run, and CMD is used to specify the parameters needed to run the command (this is a knowledge point, remember). Examples are as follows:

ENTRYPOINT ["ls"] CMD ["- a", "- l"] Thank you for reading. The above is the content of "how to create a local image in Docker". After the study of this article, I believe you have a deeper understanding of how to create a local image in Docker, and the specific usage needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.