Basic Docker Commands

Image Related Commands

# Download image
docker pull xxx
# Search image
docker search xxx
# View downloaded images
docker images
# View downloaded image IDs
docker images -q 

# Delete image 
docker rmi containerId/SOURCE_IMAGE[:TAG]
# Delete all images
docker rmi $(docker images -q)
docker images -q | xargs docker rmi 

# Delete images with tag <none>
docker rmi | xargs docker images | awk '{if ($2 == "<none>" )print $3}' | xargs docker rmi -f

Container Related Commands

# Load a local image 
docker load -i tomcat-8.0-jre.tar
# Start a container 
docker run -dp 8080:8080 tomcat-8.0-jre --name tomcat 

docker run -p 8887:8887 -it  --name myideac jetbrains/projector-idea-c
docker start myideac

# Enter interactive simulation
docker run -it debian /bin/bash
# View running containers
docker ps
# View all container IDs
docker ps -q
# View all containers
docker ps -a 
# Run, restart, stop, kill container
docker start/restart/stop/kill containerId/name

# Delete created containers
docker rm containerId/name:tag
docker rm $(docker ps -q)
# Stop containers 
docker stop $(docker ps -a | grep "Exited" | awk '{print $1 }')    
# Delete containers  
docker rm $(docker ps -a | grep "Exited" | awk '{print $1 }')      
# Delete images    
docker rmi $(docker images | grep "none" | awk '{print $3}')    

# View logs
docker logs containerId/name
# Display logs in real time
docker logs -tf containerId/name
# Logs with timestamp at line beginning
docker logs -tail  5 containerId/name

# View container resource usage
docker top containerId
# Enter container interactive mode
docker exec -it containerId bash

# Copy files/directories from container to host
docker cp containerId:/root/test.txt /root/

# Copy files/directories from host to container
docker cp a.txt containerId:/root/

# Package an image
docker commit -m "description xx" -a "author" containerId SOURCE_IMAGE[:TAG]
docker save redis:latest -o redis-cluster.tar

# Upload to docker hub repository
docker tag redis:latest docker.io/whalefall541/redis:0.01
docker push docker.io/whalefall541/redis:0.01

# View docker network configuration
docker network ls

# Create custom network bridge
docker mynetwork create mynetwork
# Assign container to created network bridge
docker run -dp 80:80 --network mynetwork redis
# Delete network bridge
docker newnetwork rm mynetwork
# View network bridge
docker inpsect mynetwork

# Data volume specification
# docker run -dp 80:80 tomcat -v /root/webapps:/root/webapps
docker run -dp 80:80 tomcat -v aa:/root/webapps
# Data volume creation
docker volume create volume_1
# Delete all unused volumes
docker volume prune 
docker rm volume_1
# View data volume
docker inspect volume_1

# Restart docker 
sudo systemctl daemon-reload 
sudo systemctl restart docker
sudo systemctl status docker

Dockerfile

• ADD
• COPY
• ENV
• EXPOSE
• FROM
• LABEL
• STOPSIGNAL
• USER
• VOLUME
• WORKDIR
• ONBUILD (when combined with one of the supported instructions above)

For detailed tutorial, please see the official website Dockerfile

how-cmd-and-entrypoint-interact

Understand how CMD and ENTRYPOINT interact

Both CMD and ENTRYPOINT instructions define what command gets executed when running a container. There are few rules that describe their co-operation.

1. Dockerfile should specify at least one of CMD or ENTRYPOINT commands.

2. ENTRYPOINT should be defined when using the container as an executable.

3. CMD should be used as a way of defining default arguments for an ENTRYPOINT command or for executing an ad-hoc command in a container.

4. CMD will be overridden when running the container with alternative arguments.

The table below shows what command is executed for different ENTRYPOINT / CMD combinations:

	No ENTRYPOINT	ENTRYPOINT exec_entry p1_entry	ENTRYPOINT ["exec_entry", "p1_entry"]
No CMD	error, not allowed	/bin/sh -c exec_entry p1_entry	exec_entry p1_entry
CMD ["exec_cmd", "p1_cmd"]	exec_cmd p1_cmd	/bin/sh -c exec_entry p1_entry	exec_entry p1_entry exec_cmd p1_cmd
CMD ["p1_cmd", "p2_cmd"]	p1_cmd p2_cmd	/bin/sh -c exec_entry p1_entry	exec_entry p1_entry p1_cmd p2_cmd
CMD exec_cmd p1_cmd	/bin/sh -c exec_cmd p1_cmd	/bin/sh -c exec_entry p1_entry	exec_entry p1_entry /bin/sh -c exec_cmd p1_cmd

Note

If CMD is defined from the base image, setting ENTRYPOINT will reset CMD to an empty value. In this scenario, CMD must be defined in the current image to have a value.

You can override the ENTRYPOINT setting using --entrypoint, but this can only set the binary to exec (no sh -c will be used).

A Simple Example

Copy springboot file to container and run with specified spring configuration file

FROM java
ENV JARNAME="demo-0.0.1-SNAPSHOT.jar"
WORKDIR /root/app
RUN /bin/bash -c "echo 'aaaa' >> 1.txt"
EXPOSE 80
VOLUME ["/root/app"]
ENTRYPOINT ["java","-jar","demo-0.0.1-SNAPSHOT.jar", "-Dspring.config.location"]
CMD ["application.yml"]

#ENTRYPOINT ["echo","/root"]
#CMD ["/root/app"]

docker build -t springboot:0.01 .
docker run -v /dockerlearn/dockerfilelearn:/root/app -p 80:80 --network rediscluster_default --rm springboot:0.01

docker run -p 8080:800 --rm learncase:latest

Note

1. If ENTRYPOINT ["exec_entry", "p1_entry"] is followed by CMD ["p1_cmd", "p2_cmd"], then all parameters in CMD will be appended to ENTRYPOINT When docker run is followed by parameters, it will override the parameters in CMD
2. CMD ENTRYPOINT array forms are both exec mode, do not support parsing local variables If you want to parse, use this command ENTRYPOINT ["sh","-c","java -jar $JARNAME"]
3. If you use ENTRYPOINT ["sh","-c",..] or directly use ENTRYPOINT "echo Hello world" then you cannot override parameters directly

References

1. Dockerfile
2. how-cmd-and-entrypoint-interact