Guest24897
/
DockerCLI
mirror of https://github.com/docker/cli.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #3661 from thaJeztah/update_images 

docs: various (minor) changes and rewording
This commit is contained in:
Sebastiaan van Stijn 2022-12-05 17:28:34 +01:00 committed by GitHub
parent b65bda6890 60833d2046
commit 74874cd0c9
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
17 changed files with 433 additions and 549 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
docs/extend/config.md
View File

@ -1,5 +1,5 @@
--- ---
description: "How develop and use a plugin with the managed plugin system" description: "How to develop and use a plugin with the managed plugin system"
keywords: "API, Usage, plugins, documentation, developer" keywords: "API, Usage, plugins, documentation, developer"
--- ---
@ -15,17 +15,14 @@ keywords: "API, Usage, plugins, documentation, developer"
# Plugin Config Version 1 of Plugin V2 # Plugin Config Version 1 of Plugin V2
This document outlines the format of the V0 plugin configuration. The plugin This document outlines the format of the V0 plugin configuration.
config described herein was introduced in the Docker daemon in the [v1.12.0
release](https://github.com/docker/docker/commit/f37117045c5398fd3dca8016ea8ca0cb47e7312b).
Plugin configs describe the various constituents of a docker plugin. Plugin Plugin configs describe the various constituents of a docker plugin. Plugin
configs can be serialized to JSON format with the following media types: configs can be serialized to JSON format with the following media types:
Config Type | Media Type | Config Type | Media Type |
------------- | ------------- |-------------|-----------------------------------------|
config | "application/vnd.docker.plugin.v1+json" | config | "application/vnd.docker.plugin.v1+json" |
## *Config* Field Descriptions ## *Config* Field Descriptions

96
docs/reference/commandline/attach.md
View File

@ -48,12 +48,12 @@ a container and leave it running using the `CTRL-p CTRL-q` key sequence.
> so. > so.
It is forbidden to redirect the standard input of a `docker attach` command It is forbidden to redirect the standard input of a `docker attach` command
while attaching to a tty-enabled container (i.e.: launched with `-t`). while attaching to a TTY-enabled container (using the `-i` and `-t` options).
While a client is connected to container's stdio using `docker attach`, Docker While a client is connected to container's `stdio` using `docker attach`, Docker
uses a ~1MB memory buffer to maximize the throughput of the application. If uses a ~1MB memory buffer to maximize the throughput of the application.
this buffer is filled, the speed of the API connection will start to have an Once this buffer is full, the speed of the API connection is affected, and so
effect on the process output writing speed. This is similar to other this impacts the output process' writing speed. This is similar to other
applications like SSH. Because of this, it is not recommended to run applications like SSH. Because of this, it is not recommended to run
performance critical applications that generate a lot of output in the performance critical applications that generate a lot of output in the
foreground over a slow client connection. Instead, users should use the foreground over a slow client connection. Instead, users should use the
@ -87,45 +87,68 @@ containers, see [**Configuration file** section](cli.md#configuration-files).
### Attach to and detach from a running container ### Attach to and detach from a running container
The following example starts an ubuntu container running `top` in detached mode,
then attaches to the container;
```console ```console
$ docker run -d --name topdemo ubuntu /usr/bin/top -b $ docker run -d --name topdemo ubuntu:22.04 /usr/bin/top -b
$ docker attach topdemo $ docker attach topdemo
top - 02:05:52 up 3:05, 0 users, load average: 0.01, 0.02, 0.05 top - 12:27:44 up 3 days, 21:54, 0 users, load average: 0.00, 0.00, 0.00
Tasks: 1 total, 1 running, 0 sleeping, 0 stopped, 0 zombie Tasks: 1 total, 1 running, 0 sleeping, 0 stopped, 0 zombie
Cpu(s): 0.1%us, 0.2%sy, 0.0%ni, 99.7%id, 0.0%wa, 0.0%hi, 0.0%si, 0.0%st %Cpu(s): 0.1 us, 0.1 sy, 0.0 ni, 99.8 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
Mem: 373572k total, 355560k used, 18012k free, 27872k buffers MiB Mem : 3934.3 total, 770.1 free, 674.2 used, 2490.1 buff/cache
Swap: 786428k total, 0k used, 786428k free, 221740k cached MiB Swap: 1024.0 total, 839.3 free, 184.7 used. 2814.0 avail Mem
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
1 root 20 0 17200 1116 912 R 0 0.3 0:00.03 top
top - 02:05:55 up 3:05, 0 users, load average: 0.01, 0.02, 0.05
Tasks: 1 total, 1 running, 0 sleeping, 0 stopped, 0 zombie
Cpu(s): 0.0%us, 0.2%sy, 0.0%ni, 99.8%id, 0.0%wa, 0.0%hi, 0.0%si, 0.0%st
Mem: 373572k total, 355244k used, 18328k free, 27872k buffers
Swap: 786428k total, 0k used, 786428k free, 221776k cached
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
1 root 20 0 17208 1144 932 R 0 0.3 0:00.03 top 1 root 20 0 7180 2896 2568 R 0.0 0.1 0:00.02 top
```
As the container was started without the `-i`, and `-t` options, signals are
forwarded to the attached process, which means that the default `CTRL-p CTRL-q`
detach key sequence produces no effect, but pressing `CTRL-c` terminates the
container:
top - 02:05:58 up 3:06, 0 users, load average: 0.01, 0.02, 0.05 ```console
Tasks: 1 total, 1 running, 0 sleeping, 0 stopped, 0 zombie <...>
Cpu(s): 0.2%us, 0.3%sy, 0.0%ni, 99.5%id, 0.0%wa, 0.0%hi, 0.0%si, 0.0%st PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
Mem: 373572k total, 355780k used, 17792k free, 27880k buffers 1 root 20 0 7180 2896 2568 R 0.0 0.1 0:00.02 top^P^Q
Swap: 786428k total, 0k used, 786428k free, 221776k cached ^C
$ docker ps -a --filter name=topdemo
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
4cf0d0ebb079 ubuntu:22.04 "/usr/bin/top -b" About a minute ago Exited (0) About a minute ago topdemo
```
Repeating the example above, but this time with the `-i` and `-t` options set;
```console
$ docker run -dit --name topdemo2 ubuntu:22.04 /usr/bin/top -b
```
Now, when attaching to the container, and pressing the `CTRL-p CTRL-q` ("read
escape sequence"), the Docker CLI is handling the detach sequence, and the
`attach` command is detached from the container. Checking the container's status
with `docker ps` shows that the container is still running in the background:
```console
$ docker attach topdemo2
top - 12:44:32 up 3 days, 22:11, 0 users, load average: 0.00, 0.00, 0.00
Tasks: 1 total, 1 running, 0 sleeping, 0 stopped, 0 zombie
%Cpu(s): 50.0 us, 0.0 sy, 0.0 ni, 50.0 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
MiB Mem : 3934.3 total, 770.6 free, 672.4 used, 2491.4 buff/cache
MiB Swap: 1024.0 total, 839.3 free, 184.7 used. 2815.8 avail Mem
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
1 root 20 0 17208 1144 932 R 0 0.3 0:00.03 top 1 root 20 0 7180 2776 2452 R 0.0 0.1 0:00.02 topread escape sequence
^C$
$ echo $? $ docker ps -a --filter name=topdemo2
0
$ docker ps -a | grep topdemo
7998ac8581f9 ubuntu:14.04 "/usr/bin/top -b" 38 seconds ago Exited (0) 21 seconds ago topdemo CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
b1661dce0fc2 ubuntu:22.04 "/usr/bin/top -b" 2 minutes ago Up 2 minutes topdemo2
``` ```
### Get the exit code of the container's command ### Get the exit code of the container's command
@ -134,18 +157,17 @@ And in this second example, you can see the exit code returned by the `bash`
process is returned by the `docker attach` command to its caller too: process is returned by the `docker attach` command to its caller too:
```console ```console
$ docker run --name test -d -it debian $ docker run --name test -dit alpine
275c44472aebd77c926d4527885bb09f2f6db21d878c75f0a1c212c03d3bcfab 275c44472aebd77c926d4527885bb09f2f6db21d878c75f0a1c212c03d3bcfab
$ docker attach test $ docker attach test
root@f38c87f2a42d:/# exit 13 /# exit 13
exit
$ echo $? $ echo $?
13 13
$ docker ps -a | grep test $ docker ps -a --filter name=test
275c44472aeb debian:7 "/bin/bash" 26 seconds ago Exited (13) 17 seconds ago test CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
a2fe3fd886db alpine "/bin/sh" About a minute ago Exited (13) 40 seconds ago test
``` ```

16
docs/reference/commandline/commit.md
View File

@ -50,8 +50,8 @@ created. Supported `Dockerfile` instructions:
$ docker ps $ docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
c3f279d17e0a ubuntu:12.04 /bin/bash 7 days ago Up 25 hours desperate_dubinsky c3f279d17e0a ubuntu:22.04 /bin/bash 7 days ago Up 25 hours desperate_dubinsky
197387f1b436 ubuntu:12.04 /bin/bash 7 days ago Up 25 hours focused_hamilton 197387f1b436 ubuntu:22.04 /bin/bash 7 days ago Up 25 hours focused_hamilton
$ docker commit c3f279d17e0a svendowideit/testimage:version3 $ docker commit c3f279d17e0a svendowideit/testimage:version3
@ -69,8 +69,8 @@ svendowideit/testimage version3 f5283438590d 16 sec
$ docker ps $ docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
c3f279d17e0a ubuntu:12.04 /bin/bash 7 days ago Up 25 hours desperate_dubinsky c3f279d17e0a ubuntu:22.04 /bin/bash 7 days ago Up 25 hours desperate_dubinsky
197387f1b436 ubuntu:12.04 /bin/bash 7 days ago Up 25 hours focused_hamilton 197387f1b436 ubuntu:22.04 /bin/bash 7 days ago Up 25 hours focused_hamilton
$ docker inspect -f "{{ .Config.Env }}" c3f279d17e0a $ docker inspect -f "{{ .Config.Env }}" c3f279d17e0a
@ -91,8 +91,8 @@ $ docker inspect -f "{{ .Config.Env }}" f5283438590d
$ docker ps $ docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
c3f279d17e0a ubuntu:12.04 /bin/bash 7 days ago Up 25 hours desperate_dubinsky c3f279d17e0a ubuntu:22.04 /bin/bash 7 days ago Up 25 hours desperate_dubinsky
197387f1b436 ubuntu:12.04 /bin/bash 7 days ago Up 25 hours focused_hamilton 197387f1b436 ubuntu:22.04 /bin/bash 7 days ago Up 25 hours focused_hamilton
$ docker commit --change='CMD ["apachectl", "-DFOREGROUND"]' -c "EXPOSE 80" c3f279d17e0a svendowideit/testimage:version4 $ docker commit --change='CMD ["apachectl", "-DFOREGROUND"]' -c "EXPOSE 80" c3f279d17e0a svendowideit/testimage:version4
@ -106,6 +106,6 @@ $ docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
89373736e2e7 testimage:version4 "apachectl -DFOREGROU" 3 seconds ago Up 2 seconds 80/tcp distracted_fermat 89373736e2e7 testimage:version4 "apachectl -DFOREGROU" 3 seconds ago Up 2 seconds 80/tcp distracted_fermat
c3f279d17e0a ubuntu:12.04 /bin/bash 7 days ago Up 25 hours desperate_dubinsky c3f279d17e0a ubuntu:22.04 /bin/bash 7 days ago Up 25 hours desperate_dubinsky
197387f1b436 ubuntu:12.04 /bin/bash 7 days ago Up 25 hours focused_hamilton 197387f1b436 ubuntu:22.04 /bin/bash 7 days ago Up 25 hours focused_hamilton
``` ```

4
docs/reference/commandline/events.md
View File

@ -343,8 +343,8 @@ $ docker events --filter 'type=network'
$ docker events --filter 'container=container_1' --filter 'container=container_2' $ docker events --filter 'container=container_1' --filter 'container=container_2'
2014-09-03T15:49:29.999999999Z07:00 container die 4386fb97867d (image=ubuntu-1:14.04) 2014-09-03T15:49:29.999999999Z07:00 container die 4386fb97867d (image=ubuntu:22.04)
2014-05-10T17:42:14.999999999Z07:00 container stop 4386fb97867d (image=ubuntu-1:14.04) 2014-05-10T17:42:14.999999999Z07:00 container stop 4386fb97867d (image=ubuntu:22.04)
2014-05-10T17:42:14.999999999Z07:00 container die 7805c1d35632 (imager=redis:2.8) 2014-05-10T17:42:14.999999999Z07:00 container die 7805c1d35632 (imager=redis:2.8)
2014-09-03T15:49:29.999999999Z07:00 container stop 7805c1d35632 (image=redis:2.8) 2014-09-03T15:49:29.999999999Z07:00 container stop 7805c1d35632 (image=redis:2.8)

79
docs/reference/commandline/exec.md
View File

@ -35,13 +35,13 @@ The command started using `docker exec` only runs while the container's primary
process (`PID 1`) is running, and it is not restarted if the container is process (`PID 1`) is running, and it is not restarted if the container is
restarted. restarted.
COMMAND will run in the default directory of the container. If the COMMAND runs in the default directory of the container. If the underlying image
underlying image has a custom directory specified with the WORKDIR directive has a custom directory specified with the WORKDIR directive in its Dockerfile,
in its Dockerfile, this will be used instead. this directory is used instead.
COMMAND should be an executable, a chained or a quoted command COMMAND must be an executable. A chained or a quoted command does not work.
will not work. Example: `docker exec -ti my_container "echo a && echo b"` will For example, `docker exec -it my_container sh -c "echo a && echo b"` works,
not work, but `docker exec -ti my_container sh -c "echo a && echo b"` will. work, but `docker exec -it my_container "echo a && echo b"` does not.
## Examples ## Examples
@ -50,70 +50,91 @@ not work, but `docker exec -ti my_container sh -c "echo a && echo b"` will.
First, start a container. First, start a container.
```console ```console
$ docker run --name ubuntu_bash --rm -i -t ubuntu bash $ docker run --name mycontainer -d -i -t alpine /bin/sh
``` ```
This will create a container named `ubuntu_bash` and start a Bash session. This creates and starts a container named `mycontainer` from an `alpine` image
with an `sh` shell as its main process. The `-d` option (shorthand for `--detach`)
sets the container to run in the background, in detached mode, with a pseudo-TTY
attached (`-t`). The `-i` option is set to keep `STDIN` attached (`-i`), which
prevents the `sh` process from exiting immediately.
Next, execute a command on the container. Next, execute a command on the container.
```console ```console
$ docker exec -d ubuntu_bash touch /tmp/execWorks $ docker exec -d mycontainer touch /tmp/execWorks
``` ```
This will create a new file `/tmp/execWorks` inside the running container This creates a new file `/tmp/execWorks` inside the running container
`ubuntu_bash`, in the background. `mycontainer`, in the background.
Next, execute an interactive `bash` shell on the container. Next, execute an interactive `sh` shell on the container.
```console ```console
$ docker exec -it ubuntu_bash bash $ docker exec -it mycontainer sh
``` ```
This will create a new Bash session in the container `ubuntu_bash`. This starts a new shell session in the container `mycontainer`.
### <a name=env></a> Set environment variables for the exec process (--env, -e)
Next, set environment variables in the current bash session. Next, set environment variables in the current bash session.
By default, the `docker exec` command, inherits the environment variables that
are set at the time the container is created. Use the `--env` (or the `-e` shorthand)
to override global environment variables, or to set additional environment variables
for the process started by `docker exec`.
The example below creates a new shell session in the container `mycontainer` with
environment variables `$VAR_A` and `$VAR_B` set to "1" and "2" respectively.
These environment variables are only valid for the `sh` process started by that
`docker exec` command, and are not available to other processes running inside
the container.
```console ```console
$ docker exec -it -e VAR_A=1 -e VAR_B=2 ubuntu_bash bash $ docker exec -e VAR_A=1 -e VAR_B=2 mycontainer env
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
HOSTNAME=f64a4851eb71
VAR_A=1
VAR_B=2
HOME=/root
``` ```
This will create a new Bash session in the container `ubuntu_bash` with environment ### <a name=workdir></a> Set the working directory for the exec process (--workdir, -w)
variables `$VAR_A` and `$VAR_B` set to "1" and "2" respectively. Note that these
environment variables will only be valid on the current Bash session.
By default `docker exec` command runs in the same working directory set when container was created. By default `docker exec` command runs in the same working directory set when
the container was created.
```console ```console
$ docker exec -it ubuntu_bash pwd $ docker exec -it mycontainer pwd
/ /
``` ```
You can select working directory for the command to execute into You can specify an alternative working directory for the command to execute
using the `--workdir` option (or the `-w` shorthand):
```console ```console
$ docker exec -it -w /root ubuntu_bash pwd $ docker exec -it -w /root mycontainer pwd
/root /root
``` ```
### Try to run `docker exec` on a paused container ### Try to run `docker exec` on a paused container
If the container is paused, then the `docker exec` command will fail with an error: If the container is paused, then the `docker exec` command fails with an error:
```console ```console
$ docker pause test $ docker pause mycontainer
mycontainer
test
$ docker ps $ docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
1ae3b36715d2 ubuntu:latest "bash" 17 seconds ago Up 16 seconds (Paused) test 482efdf39fac alpine "/bin/sh" 17 seconds ago Up 16 seconds (Paused) mycontainer
$ docker exec test ls $ docker exec mycontainer sh
FATA[0000] Error response from daemon: Container test is paused, unpause the container before exec Error response from daemon: Container mycontainer is paused, unpause the container before exec
$ echo $? $ echo $?
1 1

185
docs/reference/commandline/info.md
View File

@ -43,9 +43,9 @@ available on the volume where `/var/lib/docker` is mounted.
### Show output ### Show output
The example below shows the output for a daemon running on Red Hat Enterprise Linux, The example below shows the output for a daemon running on Ubuntu Linux,
using the `devicemapper` storage driver. As can be seen in the output, additional using the `overlay2` storage driver. As can be seen in the output, additional
information about the `devicemapper` storage driver is shown: information about the `overlay2` storage driver is shown:
```console ```console
$ docker info $ docker info
@ -53,6 +53,16 @@ $ docker info
Client: Client:
Context: default Context: default
Debug Mode: false Debug Mode: false
Plugins:
buildx: Docker Buildx (Docker Inc.)
Version: v0.8.2
Path: /usr/libexec/docker/cli-plugins/docker-buildx
compose: Docker Compose (Docker Inc.)
Version: v2.6.0
Path: /usr/libexec/docker/cli-plugins/docker-compose
scan: Docker Scan (Docker Inc.)
Version: v0.17.0
Path: /usr/libexec/docker/cli-plugins/docker-scan
Server: Server:
Containers: 14 Containers: 14
@ -60,141 +70,51 @@ Server:
Paused: 1 Paused: 1
Stopped: 10 Stopped: 10
Images: 52 Images: 52
Server Version: 1.10.3 Server Version: 22.06.0
Storage Driver: devicemapper Storage Driver: overlay2
Pool Name: docker-202:2-25583803-pool Backing Filesystem: extfs
Pool Blocksize: 65.54 kB Supports d_type: true
Base Device Size: 10.74 GB Using metacopy: false
Backing Filesystem: xfs Native Overlay Diff: true
Data file: /dev/loop0 userxattr: false
Metadata file: /dev/loop1
Data Space Used: 1.68 GB
Data Space Total: 107.4 GB
Data Space Available: 7.548 GB
Metadata Space Used: 2.322 MB
Metadata Space Total: 2.147 GB
Metadata Space Available: 2.145 GB
Udev Sync Supported: true
Deferred Removal Enabled: false
Deferred Deletion Enabled: false
Deferred Deleted Device Count: 0
Data loop file: /var/lib/docker/devicemapper/devicemapper/data
Metadata loop file: /var/lib/docker/devicemapper/devicemapper/metadata
Library Version: 1.02.107-RHEL7 (2015-12-01)
Execution Driver: native-0.2
Logging Driver: json-file Logging Driver: json-file
Cgroup Driver: systemd
Cgroup Version: 2
Plugins: Plugins:
Volume: local Volume: local
Network: null host bridge Network: bridge host ipvlan macvlan null overlay
Kernel Version: 3.10.0-327.el7.x86_64 Log: awslogs fluentd gcplogs gelf journald json-file local logentries splunk syslog
Operating System: Red Hat Enterprise Linux Server 7.2 (Maipo) Swarm: inactive
Runtimes: io.containerd.runc.v2 io.containerd.runtime.v1.linux runc
Default Runtime: runc
Init Binary: docker-init
containerd version: 212e8b6fa2f44b9c21b2798135fc6fb7c53efc16
runc version: v1.1.1-0-g52de29d
init version: de40ad0
Security Options:
apparmor
seccomp
Profile: builtin
cgroupns
Kernel Version: 5.15.0-25-generic
Operating System: Ubuntu 22.04 LTS
OSType: linux OSType: linux
Architecture: x86_64 Architecture: x86_64
CPUs: 1 CPUs: 1
Total Memory: 991.7 MiB Total Memory: 991.7 MiB
Name: ip-172-30-0-91.ec2.internal Name: ip-172-30-0-91.ec2.internal
ID: I54V:OLXT:HVMM:TPKO:JPHQ:CQCD:JNLC:O3BZ:4ZVJ:43XJ:PFHZ:6N2S ID: 4cee4408-10d2-4e17-891c-a41736ac4536
Docker Root Dir: /var/lib/docker Docker Root Dir: /var/lib/docker
Debug Mode: false Debug Mode: false
Username: gordontheturtle Username: gordontheturtle
Registry: https://index.docker.io/v1/ Registry: https://index.docker.io/v1/
Experimental: false
Insecure registries: Insecure registries:
myinsecurehost:5000 myinsecurehost:5000
127.0.0.0/8 127.0.0.0/8
```
### <a name=debug></a> Show debugging output (--debug)
Here is a sample output for a daemon running on Ubuntu, using the overlay2
storage driver and a node that is part of a 2-node swarm:
```console
$ docker --debug info
Client:
Context: default
Debug Mode: true
Server:
Containers: 14
Running: 3
Paused: 1
Stopped: 10
Images: 52
Server Version: 1.13.0
Storage Driver: overlay2
Backing Filesystem: extfs
Supports d_type: true
Native Overlay Diff: false
Logging Driver: json-file
Cgroup Driver: cgroupfs
Plugins:
Volume: local
Network: bridge host macvlan null overlay
Swarm: active
NodeID: rdjq45w1op418waxlairloqbm
Is Manager: true
ClusterID: te8kdyw33n36fqiz74bfjeixd
Managers: 1
Nodes: 2
Orchestration:
Task History Retention Limit: 5
Raft:
Snapshot Interval: 10000
Number of Old Snapshots to Retain: 0
Heartbeat Tick: 1
Election Tick: 3
Dispatcher:
Heartbeat Period: 5 seconds
CA Configuration:
Expiry Duration: 3 months
Root Rotation In Progress: false
Node Address: 172.16.66.128 172.16.66.129
Manager Addresses:
172.16.66.128:2477
Runtimes: runc
Default Runtime: runc
Init Binary: docker-init
containerd version: 8517738ba4b82aff5662c97ca4627e7e4d03b531
runc version: ac031b5bf1cc92239461125f4c1ffb760522bbf2
init version: N/A (expected: v0.13.0)
Security Options:
apparmor
seccomp
Profile: default
Kernel Version: 4.4.0-31-generic
Operating System: Ubuntu 16.04.1 LTS
OSType: linux
Architecture: x86_64
CPUs: 2
Total Memory: 1.937 GiB
Name: ubuntu
ID: H52R:7ZR6:EIIA:76JG:ORIY:BVKF:GSFU:HNPG:B5MK:APSC:SZ3Q:N326
Docker Root Dir: /var/lib/docker
Debug Mode: true
File Descriptors: 30
Goroutines: 123
System Time: 2016-11-12T17:24:37.955404361-08:00
EventsListeners: 0
Http Proxy: http://test:test@proxy.example.com:8080
Https Proxy: https://test:test@proxy.example.com:8080
No Proxy: localhost,127.0.0.1,docker-registry.somecorporation.com
Registry: https://index.docker.io/v1/
WARNING: No swap limit support
Labels:
storage=ssd
staging=true
Experimental: false
Insecure Registries:
127.0.0.0/8
Registry Mirrors:
http://192.168.1.2/
http://registry-mirror.example.com:5000/
Live Restore Enabled: false Live Restore Enabled: false
``` ```
The global `-D` option causes all `docker` commands to output debug information.
### <a name=format></a> Format the output (--format) ### <a name=format></a> Format the output (--format)
You can also specify the output format: You can also specify the output format:
@ -207,13 +127,18 @@ $ docker info --format '{{json .}}'
### Run `docker info` on Windows ### Run `docker info` on Windows
Here is a sample output for a daemon running on Windows Server 2016: Here is a sample output for a daemon running on Windows Server:
```console ```console
E:\docker>docker info C:\> docker info
Client: Client:
Context: default Context: default
Debug Mode: false Debug Mode: false
Plugins:
buildx: Docker Buildx (Docker Inc., v0.8.2-docker)
compose: Docker Compose (Docker Inc., v2.6.0)
scan: Docker Scan (Docker Inc., v0.17.0)
Server: Server:
Containers: 1 Containers: 1
@ -221,27 +146,29 @@ Server:
Paused: 0 Paused: 0
Stopped: 1 Stopped: 1
Images: 17 Images: 17
Server Version: 1.13.0 Server Version: 20.10.16
Storage Driver: windowsfilter Storage Driver: windowsfilter
Windows:
Logging Driver: json-file Logging Driver: json-file
Plugins: Plugins:
Volume: local Volume: local
Network: nat null overlay Network: ics internal l2bridge l2tunnel nat null overlay private transparent
Log: awslogs etwlogs fluentd gcplogs gelf json-file local logentries splunk syslog
Swarm: inactive Swarm: inactive
Default Isolation: process Default Isolation: process
Kernel Version: 10.0 14393 (14393.206.amd64fre.rs1_release.160912-1937) Kernel Version: 10.0 20348 (20348.1.amd64fre.fe_release.210507-1500)
Operating System: Windows Server 2016 Datacenter Operating System: Microsoft Windows Server Version 21H2 (OS Build 20348.707)
OSType: windows OSType: windows
Architecture: x86_64 Architecture: x86_64
CPUs: 8 CPUs: 8
Total Memory: 3.999 GiB Total Memory: 3.999 GiB
Name: WIN-V0V70C0LU5P Name: WIN-V0V70C0LU5P
ID: NYMS:B5VK:UMSL:FVDZ:EWB5:FKVK:LPFL:FJMQ:H6FT:BZJ6:L2TD:XH62 ID: 2880d38d-464e-4d01-91bd-c76f33ba3981
Docker Root Dir: C:\control Docker Root Dir: C:\ProgramData\docker
Debug Mode: false Debug Mode: false
Registry: https://index.docker.io/v1/ Registry: https://index.docker.io/v1/
Experimental: true
Insecure Registries: Insecure Registries:
myregistry:5000
127.0.0.0/8 127.0.0.0/8
Registry Mirrors: Registry Mirrors:
http://192.168.1.2/ http://192.168.1.2/

10
docs/reference/commandline/ps.md
View File

@ -57,7 +57,7 @@ Running `docker ps --no-trunc` showing 2 linked containers.
$ docker ps --no-trunc $ docker ps --no-trunc
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
4c01db0b339c ubuntu:12.04 bash 17 seconds ago Up 16 seconds 3300-3310/tcp webapp 4c01db0b339c ubuntu:22.04 bash 17 seconds ago Up 16 seconds 3300-3310/tcp webapp
d7886598dbe2 crosbymichael/redis:latest /redis-server --dir 33 minutes ago Up 33 minutes 6379/tcp redis,webapp/db d7886598dbe2 crosbymichael/redis:latest /redis-server --dir 33 minutes ago Up 33 minutes 6379/tcp redis,webapp/db
``` ```
@ -254,13 +254,13 @@ CONTAINER ID IMAGE COMMAND CREATED
919e1179bdb8 ubuntu-c1 "top" About a minute ago Up About a minute admiring_lovelace 919e1179bdb8 ubuntu-c1 "top" About a minute ago Up About a minute admiring_lovelace
``` ```
Match containers based on the `ubuntu` version `12.04.5` image: Match containers based on the `ubuntu` version `22.04` image:
```console ```console
$ docker ps --filter ancestor=ubuntu:12.04.5 $ docker ps --filter ancestor=ubuntu:22.04
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
82a598284012 ubuntu:12.04.5 "top" 3 minutes ago Up 3 minutes sleepy_bose 82a598284012 ubuntu:22.04 "top" 3 minutes ago Up 3 minutes sleepy_bose
``` ```
The following matches containers based on the layer `d0e008c6cf02` or an image The following matches containers based on the layer `d0e008c6cf02` or an image
@ -270,7 +270,7 @@ that have this layer in its layer stack.
$ docker ps --filter ancestor=d0e008c6cf02 $ docker ps --filter ancestor=d0e008c6cf02
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
82a598284012 ubuntu:12.04.5 "top" 3 minutes ago Up 3 minutes sleepy_bose 82a598284012 ubuntu:22.04 "top" 3 minutes ago Up 3 minutes sleepy_bose
``` ```
#### Create time #### Create time

122
docs/reference/commandline/pull.md
View File

@ -53,36 +53,36 @@ this via the `--max-concurrent-downloads` daemon option. See the
### Pull an image from Docker Hub ### Pull an image from Docker Hub
To download a particular image, or set of images (i.e., a repository), use To download a particular image, or set of images (i.e., a repository), use
`docker pull`. If no tag is provided, Docker Engine uses the `:latest` tag as a `docker image pull` (or the `docker pull` shorthand). If no tag is provided,
default. This command pulls the `debian:latest` image: Docker Engine uses the `:latest` tag as a default. This example pulls the
`debian:latest` image:
```console ```console
$ docker pull debian $ docker image pull debian
Using default tag: latest Using default tag: latest
latest: Pulling from library/debian latest: Pulling from library/debian
fdd5d7827f33: Pull complete e756f3fdd6a3: Pull complete
a3ed95caeb02: Pull complete Digest: sha256:3f1d6c17773a45c97bd8f158d665c9709d7b29ed7917ac934086ad96f92e4510
Digest: sha256:e7d38b3517548a1c71e41bffe9c8ae6d6d29546ce46bf62159837aad072c90aa
Status: Downloaded newer image for debian:latest Status: Downloaded newer image for debian:latest
docker.io/library/debian:latest
``` ```
Docker images can consist of multiple layers. In the example above, the image Docker images can consist of multiple layers. In the example above, the image
consists of two layers; `fdd5d7827f33` and `a3ed95caeb02`. consists of a single layer; `e756f3fdd6a3`.
Layers can be reused by images. For example, the `debian:jessie` image shares Layers can be reused by images. For example, the `debian:bullseye` image shares
both layers with `debian:latest`. Pulling the `debian:jessie` image therefore its layer with the `debian:latest`. Pulling the `debian:bullseye` image therefore
only pulls its metadata, but not its layers, because all layers are already only pulls its metadata, but not its layers, because the layer is already present
present locally: locally:
```console ```console
$ docker pull debian:jessie $ docker image pull debian:bullseye
jessie: Pulling from library/debian bullseye: Pulling from library/debian
fdd5d7827f33: Already exists Digest: sha256:3f1d6c17773a45c97bd8f158d665c9709d7b29ed7917ac934086ad96f92e4510
a3ed95caeb02: Already exists Status: Downloaded newer image for debian:bullseye
Digest: sha256:a9c958be96d7d40df920e7041608f2f017af81800ca5ad23e327bc402626b58e docker.io/library/debian:bullseye
Status: Downloaded newer image for debian:jessie
``` ```
To see which images are present locally, use the [`docker images`](images.md) To see which images are present locally, use the [`docker images`](images.md)
@ -92,16 +92,15 @@ command:
$ docker images $ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE REPOSITORY TAG IMAGE ID CREATED SIZE
debian jessie f50f9524513f 5 days ago 125.1 MB debian bullseye 4eacea30377a 8 days ago 124MB
debian latest f50f9524513f 5 days ago 125.1 MB debian latest 4eacea30377a 8 days ago 124MB
``` ```
Docker uses a content-addressable image store, and the image ID is a SHA256 Docker uses a content-addressable image store, and the image ID is a SHA256
digest covering the image's configuration and layers. In the example above, digest covering the image's configuration and layers. In the example above,
`debian:jessie` and `debian:latest` have the same image ID because they are `debian:bullseye` and `debian:latest` have the same image ID because they are
actually the *same* image tagged with different names. Because they are the the *same* image tagged with different names. Because they are the same image,
same image, their layers are stored only once and do not consume extra disk their layers are stored only once and do not consume extra disk space.
space.
For more information about images, layers, and the content-addressable store, For more information about images, layers, and the content-addressable store,
refer to [understand images, containers, and storage drivers](https://docs.docker.com/storage/storagedriver/). refer to [understand images, containers, and storage drivers](https://docs.docker.com/storage/storagedriver/).
@ -112,8 +111,8 @@ refer to [understand images, containers, and storage drivers](https://docs.docke
So far, you've pulled images by their name (and "tag"). Using names and tags is So far, you've pulled images by their name (and "tag"). Using names and tags is
a convenient way to work with images. When using tags, you can `docker pull` an a convenient way to work with images. When using tags, you can `docker pull` an
image again to make sure you have the most up-to-date version of that image. image again to make sure you have the most up-to-date version of that image.
For example, `docker pull ubuntu:20.04` pulls the latest version of the Ubuntu For example, `docker pull ubuntu:22.04` pulls the latest version of the Ubuntu
20.04 image. 22.04 image.
In some cases you don't want images to be updated to newer versions, but prefer In some cases you don't want images to be updated to newer versions, but prefer
to use a fixed version of an image. Docker enables you to pull an image by its to use a fixed version of an image. Docker enables you to pull an image by its
@ -122,23 +121,23 @@ of an image to pull. Doing so, allows you to "pin" an image to that version,
and guarantee that the image you're using is always the same. and guarantee that the image you're using is always the same.
To know the digest of an image, pull the image first. Let's pull the latest To know the digest of an image, pull the image first. Let's pull the latest
`ubuntu:20.04` image from Docker Hub: `ubuntu:22.04` image from Docker Hub:
```console ```console
$ docker pull ubuntu:20.04 $ docker pull ubuntu:22.04
20.04: Pulling from library/ubuntu 22.04: Pulling from library/ubuntu
16ec32c2132b: Pull complete 125a6e411906: Pull complete
Digest: sha256:82becede498899ec668628e7cb0ad87b6e1c371cb8a1e597d83a47fac21d6af3 Digest: sha256:26c68657ccce2cb0a31b330cb0be2b5e108d467f641c62e13ab40cbec258c68d
Status: Downloaded newer image for ubuntu:20.04 Status: Downloaded newer image for ubuntu:22.04
docker.io/library/ubuntu:20.04 docker.io/library/ubuntu:22.04
``` ```
Docker prints the digest of the image after the pull has finished. In the example Docker prints the digest of the image after the pull has finished. In the example
above, the digest of the image is: above, the digest of the image is:
```console ```console
sha256:82becede498899ec668628e7cb0ad87b6e1c371cb8a1e597d83a47fac21d6af3 sha256:26c68657ccce2cb0a31b330cb0be2b5e108d467f641c62e13ab40cbec258c68d
``` ```
Docker also prints the digest of an image when *pushing* to a registry. This Docker also prints the digest of an image when *pushing* to a registry. This
@ -148,25 +147,25 @@ A digest takes the place of the tag when pulling an image, for example, to
pull the above image by digest, run the following command: pull the above image by digest, run the following command:
```console ```console
$ docker pull ubuntu@sha256:82becede498899ec668628e7cb0ad87b6e1c371cb8a1e597d83a47fac21d6af3 $ docker pull ubuntu@sha256:26c68657ccce2cb0a31b330cb0be2b5e108d467f641c62e13ab40cbec258c68d
docker.io/library/ubuntu@sha256:82becede498899ec668628e7cb0ad87b6e1c371cb8a1e597d83a47fac21d6af3: Pulling from library/ubuntu docker.io/library/ubuntu@sha256:26c68657ccce2cb0a31b330cb0be2b5e108d467f641c62e13ab40cbec258c68d: Pulling from library/ubuntu
Digest: sha256:82becede498899ec668628e7cb0ad87b6e1c371cb8a1e597d83a47fac21d6af3 Digest: sha256:26c68657ccce2cb0a31b330cb0be2b5e108d467f641c62e13ab40cbec258c68d
Status: Image is up to date for ubuntu@sha256:82becede498899ec668628e7cb0ad87b6e1c371cb8a1e597d83a47fac21d6af3 Status: Image is up to date for ubuntu@sha256:26c68657ccce2cb0a31b330cb0be2b5e108d467f641c62e13ab40cbec258c68d
docker.io/library/ubuntu@sha256:82becede498899ec668628e7cb0ad87b6e1c371cb8a1e597d83a47fac21d6af3 docker.io/library/ubuntu@sha256:26c68657ccce2cb0a31b330cb0be2b5e108d467f641c62e13ab40cbec258c68d
``` ```
Digest can also be used in the `FROM` of a Dockerfile, for example: Digest can also be used in the `FROM` of a Dockerfile, for example:
```dockerfile ```dockerfile
FROM ubuntu@sha256:82becede498899ec668628e7cb0ad87b6e1c371cb8a1e597d83a47fac21d6af3 FROM ubuntu@sha256:26c68657ccce2cb0a31b330cb0be2b5e108d467f641c62e13ab40cbec258c68d
LABEL org.opencontainers.image.authors="some maintainer <maintainer@example.com>" LABEL org.opencontainers.image.authors="some maintainer <maintainer@example.com>"
``` ```
> **Note** > **Note**
> >
> Using this feature "pins" an image to a specific version in time. > Using this feature "pins" an image to a specific version in time.
> Docker will therefore not pull updated versions of an image, which may include > Docker does therefore not pull updated versions of an image, which may include
> security updates. If you want to pull an updated image, you need to change the > security updates. If you want to pull an updated image, you need to change the
> digest accordingly. > digest accordingly.
@ -182,7 +181,7 @@ The following command pulls the `testing/test-image` image from a local registry
listening on port 5000 (`myregistry.local:5000`): listening on port 5000 (`myregistry.local:5000`):
```console ```console
$ docker pull myregistry.local:5000/testing/test-image $ docker image pull myregistry.local:5000/testing/test-image
``` ```
Registry credentials are managed by [docker login](login.md). Registry credentials are managed by [docker login](login.md).
@ -198,33 +197,35 @@ By default, `docker pull` pulls a *single* image from the registry. A repository
can contain multiple images. To pull all images from a repository, provide the can contain multiple images. To pull all images from a repository, provide the
`-a` (or `--all-tags`) option when using `docker pull`. `-a` (or `--all-tags`) option when using `docker pull`.
This command pulls all images from the `fedora` repository: This command pulls all images from the `ubuntu` repository:
```console ```console
$ docker pull --all-tags fedora $ docker image pull --all-tags ubuntu
Pulling repository fedora Pulling repository ubuntu
ad57ef8d78d7: Download complete ad57ef8d78d7: Download complete
105182bb5e8b: Download complete 105182bb5e8b: Download complete
511136ea3c5a: Download complete 511136ea3c5a: Download complete
73bd853d2ea5: Download complete 73bd853d2ea5: Download complete
.... ....
Status: Downloaded newer image for fedora Status: Downloaded newer image for ubuntu
``` ```
After the pull has completed use the `docker images` command to see the After the pull has completed use the `docker image ls` command (or the `docker images`
images that were pulled. The example below shows all the `fedora` images shorthand) to see the images that were pulled. The example below shows all the
that are present locally: `ubuntu` images that are present locally:
```console ```console
$ docker images fedora $ docker image ls --filter reference=ubuntu
REPOSITORY TAG IMAGE ID CREATED SIZE REPOSITORY TAG IMAGE ID CREATED SIZE
fedora rawhide ad57ef8d78d7 5 days ago 359.3 MB ubuntu 18.04 c6ad7e71ba7d 5 weeks ago 63.2MB
fedora 20 105182bb5e8b 5 days ago 372.7 MB ubuntu bionic c6ad7e71ba7d 5 weeks ago 63.2MB
fedora heisenbug 105182bb5e8b 5 days ago 372.7 MB ubuntu 22.04 5ccefbfc0416 2 months ago 78MB
fedora latest 105182bb5e8b 5 days ago 372.7 MB ubuntu focal ff0fea8310f3 2 months ago 72.8MB
ubuntu latest ff0fea8310f3 2 months ago 72.8MB
ubuntu jammy 41ba606c8ab9 3 months ago 79MB
ubuntu 20.04 ba6acccedd29 7 months ago 72.8MB
``` ```
### Cancel a pull ### Cancel a pull
@ -233,18 +234,15 @@ Killing the `docker pull` process, for example by pressing `CTRL-c` while it is
running in a terminal, will terminate the pull operation. running in a terminal, will terminate the pull operation.
```console ```console
$ docker pull fedora $ docker pull ubuntu
Using default tag: latest Using default tag: latest
latest: Pulling from library/fedora latest: Pulling from library/ubuntu
a3ed95caeb02: Pulling fs layer a3ed95caeb02: Pulling fs layer
236608c7b546: Pulling fs layer 236608c7b546: Pulling fs layer
^C ^C
``` ```
> **Note** The Engine terminates a pull operation when the connection between the daemon
> and the client (initiating the pull) is cut or lost for any reason or the
> The Engine terminates a pull operation when the connection between the Docker command is manually terminated.
> Engine daemon and the Docker Engine client initiating the pull is lost. If the
> connection with the Engine daemon is lost for other reasons than a manual
> interaction, the pull is also aborted.

2
docs/reference/commandline/service_create.md
View File

@ -678,7 +678,7 @@ follows:
| `node.platform.os` | Node operating system | `node.platform.os==windows` | | `node.platform.os` | Node operating system | `node.platform.os==windows` |
| `node.platform.arch` | Node architecture | `node.platform.arch==x86_64` | | `node.platform.arch` | Node architecture | `node.platform.arch==x86_64` |
| `node.labels` | User-defined node labels | `node.labels.security==high` | | `node.labels` | User-defined node labels | `node.labels.security==high` |
| `engine.labels` | Docker Engine's labels | `engine.labels.operatingsystem==ubuntu-14.04` | | `engine.labels` | Docker Engine's labels | `engine.labels.operatingsystem==ubuntu-22.04` |
`engine.labels` apply to Docker Engine labels like operating system, drivers, `engine.labels` apply to Docker Engine labels like operating system, drivers,
etc. Swarm administrators add `node.labels` for operational purposes by using etc. Swarm administrators add `node.labels` for operational purposes by using

4
docs/reference/commandline/system_events.md
View File

@ -281,8 +281,8 @@ $ docker system events --filter 'type=network'
$ docker system events --filter 'container=container_1' --filter 'container=container_2' $ docker system events --filter 'container=container_1' --filter 'container=container_2'
2014-09-03T15:49:29.999999999Z07:00 container die 4386fb97867d (image=ubuntu-1:14.04) 2014-09-03T15:49:29.999999999Z07:00 container die 4386fb97867d (image=ubuntu:22.04 )
2014-05-10T17:42:14.999999999Z07:00 container stop 4386fb97867d (image=ubuntu-1:14.04) 2014-05-10T17:42:14.999999999Z07:00 container stop 4386fb97867d (image=ubuntu:22.04 )
2014-05-10T17:42:14.999999999Z07:00 container die 7805c1d35632 (imager=redis:2.8) 2014-05-10T17:42:14.999999999Z07:00 container die 7805c1d35632 (imager=redis:2.8)
2014-09-03T15:49:29.999999999Z07:00 container stop 7805c1d35632 (image=redis:2.8) 2014-09-03T15:49:29.999999999Z07:00 container stop 7805c1d35632 (image=redis:2.8)

42
docs/reference/run.md
View File

@ -187,7 +187,7 @@ PID files):
While not strictly a means of identifying a container, you can specify a version of an While not strictly a means of identifying a container, you can specify a version of an
image you'd like to run the container with by adding `image[:tag]` to the command. For image you'd like to run the container with by adding `image[:tag]` to the command. For
example, `docker run ubuntu:14.04`. example, `docker run ubuntu:22.04`.
### Image[@digest] ### Image[@digest]
@ -837,14 +837,14 @@ We have four ways to set user memory usage:
Examples: Examples:
```console ```console
$ docker run -it ubuntu:14.04 /bin/bash $ docker run -it ubuntu:22.04 /bin/bash
``` ```
We set nothing about memory, this means the processes in the container can use We set nothing about memory, this means the processes in the container can use
as much memory and swap memory as they need. as much memory and swap memory as they need.
```console ```console
$ docker run -it -m 300M --memory-swap -1 ubuntu:14.04 /bin/bash $ docker run -it -m 300M --memory-swap -1 ubuntu:22.04 /bin/bash
``` ```
We set memory limit and disabled swap memory limit, this means the processes in We set memory limit and disabled swap memory limit, this means the processes in
@ -852,7 +852,7 @@ the container can use 300M memory and as much swap memory as they need (if the
host supports swap memory). host supports swap memory).
```console ```console
$ docker run -it -m 300M ubuntu:14.04 /bin/bash $ docker run -it -m 300M ubuntu:22.04 /bin/bash
``` ```
We set memory limit only, this means the processes in the container can use We set memory limit only, this means the processes in the container can use
@ -861,7 +861,7 @@ We set memory limit only, this means the processes in the container can use
would be 2*300M, so processes can use 300M swap memory as well. would be 2*300M, so processes can use 300M swap memory as well.
```console ```console
$ docker run -it -m 300M --memory-swap 1G ubuntu:14.04 /bin/bash $ docker run -it -m 300M --memory-swap 1G ubuntu:22.04 /bin/bash
``` ```
We set both memory and swap memory, so the processes in the container can use We set both memory and swap memory, so the processes in the container can use
@ -887,7 +887,7 @@ The following example limits the memory (`-m`) to 500M and sets the memory
reservation to 200M. reservation to 200M.
```console ```console
$ docker run -it -m 500M --memory-reservation 200M ubuntu:14.04 /bin/bash $ docker run -it -m 500M --memory-reservation 200M ubuntu:22.04 /bin/bash
``` ```
Under this configuration, when the container consumes memory more than 200M and Under this configuration, when the container consumes memory more than 200M and
@ -897,7 +897,7 @@ memory below 200M.
The following example set memory reservation to 1G without a hard memory limit. The following example set memory reservation to 1G without a hard memory limit.
```console ```console
$ docker run -it --memory-reservation 1G ubuntu:14.04 /bin/bash $ docker run -it --memory-reservation 1G ubuntu:22.04 /bin/bash
``` ```
The container can use as much memory as it needs. The memory reservation setting The container can use as much memory as it needs. The memory reservation setting
@ -915,13 +915,13 @@ The following example limits the memory to 100M and disables the OOM killer for
this container: this container:
```console ```console
$ docker run -it -m 100M --oom-kill-disable ubuntu:14.04 /bin/bash $ docker run -it -m 100M --oom-kill-disable ubuntu:22.04 /bin/bash
``` ```
The following example, illustrates a dangerous way to use the flag: The following example, illustrates a dangerous way to use the flag:
```console ```console
$ docker run -it --oom-kill-disable ubuntu:14.04 /bin/bash $ docker run -it --oom-kill-disable ubuntu:22.04 /bin/bash
``` ```
The container has unlimited memory which can cause the host to run out memory The container has unlimited memory which can cause the host to run out memory
@ -991,14 +991,14 @@ limit and "K" the kernel limit. There are three possible ways to set limits:
Examples: Examples:
```console ```console
$ docker run -it -m 500M --kernel-memory 50M ubuntu:14.04 /bin/bash $ docker run -it -m 500M --kernel-memory 50M ubuntu:22.04 /bin/bash
``` ```
We set memory and kernel memory, so the processes in the container can use We set memory and kernel memory, so the processes in the container can use
500M memory in total, in this 500M memory, it can be 50M kernel memory tops. 500M memory in total, in this 500M memory, it can be 50M kernel memory tops.
```console ```console
$ docker run -it --kernel-memory 50M ubuntu:14.04 /bin/bash $ docker run -it --kernel-memory 50M ubuntu:22.04 /bin/bash
``` ```
We set kernel memory without **-m**, so the processes in the container can We set kernel memory without **-m**, so the processes in the container can
@ -1015,7 +1015,7 @@ between 0 and 100. A value of 0 turns off anonymous page swapping. A value of
For example, you can set: For example, you can set:
```console ```console
$ docker run -it --memory-swappiness=0 ubuntu:14.04 /bin/bash $ docker run -it --memory-swappiness=0 ubuntu:22.04 /bin/bash
``` ```
Setting the `--memory-swappiness` option is helpful when you want to retain the Setting the `--memory-swappiness` option is helpful when you want to retain the
@ -1066,7 +1066,7 @@ And usually `--cpu-period` should work with `--cpu-quota`.
Examples: Examples:
```console ```console
$ docker run -it --cpu-period=50000 --cpu-quota=25000 ubuntu:14.04 /bin/bash $ docker run -it --cpu-period=50000 --cpu-quota=25000 ubuntu:22.04 /bin/bash
``` ```
If there is 1 CPU, this means the container can get 50% CPU worth of run-time every 50ms. If there is 1 CPU, this means the container can get 50% CPU worth of run-time every 50ms.
@ -1087,13 +1087,13 @@ We can set cpus in which to allow execution for containers.
Examples: Examples:
```console ```console
$ docker run -it --cpuset-cpus="1,3" ubuntu:14.04 /bin/bash $ docker run -it --cpuset-cpus="1,3" ubuntu:22.04 /bin/bash
``` ```
This means processes in container can be executed on cpu 1 and cpu 3. This means processes in container can be executed on cpu 1 and cpu 3.
```console ```console
$ docker run -it --cpuset-cpus="0-2" ubuntu:14.04 /bin/bash $ docker run -it --cpuset-cpus="0-2" ubuntu:22.04 /bin/bash
``` ```
This means processes in container can be executed on cpu 0, cpu 1 and cpu 2. This means processes in container can be executed on cpu 0, cpu 1 and cpu 2.
@ -1104,14 +1104,14 @@ on NUMA systems.
Examples: Examples:
```console ```console
$ docker run -it --cpuset-mems="1,3" ubuntu:14.04 /bin/bash $ docker run -it --cpuset-mems="1,3" ubuntu:22.04 /bin/bash
``` ```
This example restricts the processes in the container to only use memory from This example restricts the processes in the container to only use memory from
memory nodes 1 and 3. memory nodes 1 and 3.
```console ```console
$ docker run -it --cpuset-mems="0-2" ubuntu:14.04 /bin/bash $ docker run -it --cpuset-mems="0-2" ubuntu:22.04 /bin/bash
``` ```
This example restricts the processes in the container to only use memory from This example restricts the processes in the container to only use memory from
@ -1143,8 +1143,8 @@ For example, the commands below create two containers with different blkio
weight: weight:
```console ```console
$ docker run -it --name c1 --blkio-weight 300 ubuntu:14.04 /bin/bash $ docker run -it --name c1 --blkio-weight 300 ubuntu:22.04 /bin/bash
$ docker run -it --name c2 --blkio-weight 600 ubuntu:14.04 /bin/bash $ docker run -it --name c2 --blkio-weight 600 ubuntu:22.04 /bin/bash
``` ```
If you do block IO in the two containers at the same time, by, for example: If you do block IO in the two containers at the same time, by, for example:
@ -1359,11 +1359,11 @@ For interacting with the network stack, instead of using `--privileged` they
should use `--cap-add=NET_ADMIN` to modify the network interfaces. should use `--cap-add=NET_ADMIN` to modify the network interfaces.
```console ```console
$ docker run -it --rm ubuntu:14.04 ip link add dummy0 type dummy $ docker run -it --rm ubuntu:22.04 ip link add dummy0 type dummy
RTNETLINK answers: Operation not permitted RTNETLINK answers: Operation not permitted
$ docker run -it --rm --cap-add=NET_ADMIN ubuntu:14.04 ip link add dummy0 type dummy $ docker run -it --rm --cap-add=NET_ADMIN ubuntu:22.04 ip link add dummy0 type dummy
``` ```
To mount a FUSE based filesystem, you need to combine both `--cap-add` and To mount a FUSE based filesystem, you need to combine both `--cap-add` and

22
man/src/container/attach.md
View File

@ -11,7 +11,7 @@ configure the key sequence using the **--detach-keys** option or a configuration
file. See **config-json(5)** for documentation on using a configuration file. file. See **config-json(5)** for documentation on using a configuration file.
It is forbidden to redirect the standard input of a **docker attach** command while It is forbidden to redirect the standard input of a **docker attach** command while
attaching to a tty-enabled container (i.e.: launched with `-t`). attaching to a TTY-enabled container (i.e., launched with `-i` and `-t`).
# Override the detach sequence # Override the detach sequence
@ -41,12 +41,12 @@ containers, see **docker(1)**.
## Attaching to a container ## Attaching to a container
In this example the top command is run inside a container, from an image called In this example the top command is run inside a container from an ubuntu image,
fedora, in detached mode. The ID from the container is passed into the **docker in detached mode, then attaches to it, and then terminates the container
attach** command: with `CTRL-c`:
$ ID=$(sudo docker run -d ubuntu:20.04 /usr/bin/top -b) $ docker run -d --name topdemo ubuntu:20.04 /usr/bin/top -b
$ sudo docker attach $ID $ docker attach topdemo
top - 00:07:01 up 4:54, 0 users, load average: 0.83, 0.91, 0.82 top - 00:07:01 up 4:54, 0 users, load average: 0.83, 0.91, 0.82
Tasks: 1 total, 1 running, 0 sleeping, 0 stopped, 0 zombie Tasks: 1 total, 1 running, 0 sleeping, 0 stopped, 0 zombie
%Cpu(s): 2.3 us, 1.6 sy, 0.0 ni, 95.9 id, 0.0 wa, 0.1 hi, 0.1 si, 0.0 st %Cpu(s): 2.3 us, 1.6 sy, 0.0 ni, 95.9 id, 0.0 wa, 0.1 hi, 0.1 si, 0.0 st
@ -55,12 +55,4 @@ attach** command:
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
1 root 20 0 5976 3256 2828 R 0.0 0.0 0:00.04 top 1 root 20 0 5976 3256 2828 R 0.0 0.0 0:00.04 top
^C
top - 00:07:04 up 4:54, 0 users, load average: 0.76, 0.89, 0.81
Tasks: 1 total, 1 running, 0 sleeping, 0 stopped, 0 zombie
%Cpu(s): 2.0 us, 1.4 sy, 0.0 ni, 96.5 id, 0.0 wa, 0.1 hi, 0.0 si, 0.0 st
MiB Mem : 15846.2 total, 5727.5 free, 2594.4 used, 7524.3 buff/cache
MiB Swap: 16384.0 total, 16384.0 free, 0.0 used. 12095.6 avail Mem
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
1 root 20 0 5976 3256 2828 R 0.0 0.0 0:00.04 top

12
man/src/container/ls.md
View File

@ -48,10 +48,10 @@ Valid placeholders for the Go template are listed below:
$ docker container ls -a $ docker container ls -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
a87ecb4f327c fedora:20 /bin/sh -c #(nop) MA 20 minutes ago Exit 0 desperate_brattain a87ecb4f327c ubuntu:22.04 /bin/sh -c #(nop) MA 20 minutes ago Exit 0 desperate_brattain
01946d9d34d8 vpavlin/rhel7:latest /bin/sh -c #(nop) MA 33 minutes ago Exit 0 thirsty_bell 01946d9d34d8 busybox /bin/sh -c #(nop) MA 33 minutes ago Exit 0 thirsty_bell
c1d3b0166030 acffc0358b9e /bin/sh -c yum -y up 2 weeks ago Exit 1 determined_torvalds c1d3b0166030 acffc0358b9e /bin/sh -c yum -y up 2 weeks ago Exit 1 determined_torvalds
41d50ecd2f57 fedora:20 /bin/sh -c #(nop) MA 2 weeks ago Exit 0 drunk_pike 41d50ecd2f57 ubuntu:22.04 /bin/sh -c #(nop) MA 2 weeks ago Exit 0 drunk_pike
## Display only IDs of all containers, including non-running ## Display only IDs of all containers, including non-running
@ -87,10 +87,10 @@ Valid placeholders for the Go template are listed below:
$ docker container ls --format 'table {{.ID}}\t{{(.Label "com.docker.swarm.node")}}' $ docker container ls --format 'table {{.ID}}\t{{(.Label "com.docker.swarm.node")}}'
CONTAINER ID NODE CONTAINER ID NODE
a87ecb4f327c ubuntu a87ecb4f327c worker-1
01946d9d34d8 01946d9d34d8
c1d3b0166030 debian c1d3b0166030 worker-1
41d50ecd2f57 fedora 41d50ecd2f57 worker-2
## Display containers with `remote-volume` mounted ## Display containers with `remote-volume` mounted

2
man/src/image/ls.md
View File

@ -10,7 +10,7 @@ The title REPOSITORY for the first title may seem confusing. It is essentially
the image name. However, because you can tag a specific image, and multiple tags the image name. However, because you can tag a specific image, and multiple tags
(image instances) can be associated with a single name, the name is really a (image instances) can be associated with a single name, the name is really a
repository for all tagged images of the same name. For example consider an image repository for all tagged images of the same name. For example consider an image
called fedora. It may be tagged with 18, 19, or 20, etc. to manage different called ubuntu. It may be tagged with 20.04 or 22.04, etc. to manage different
versions. versions.
## Filters ## Filters

134
man/src/image/pull.md
View File

@ -11,33 +11,33 @@ registry located at `registry-1.docker.io` by default.
### Pull an image from Docker Hub ### Pull an image from Docker Hub
To download a particular image, or set of images (i.e., a repository), use To download a particular image, or set of images (i.e., a repository), use
`docker image pull`. If no tag is provided, Docker Engine uses the `:latest` tag as a `docker image pull` (or the `docker pull` shorthand). If no tag is provided,
default. This command pulls the `debian:latest` image: Docker Engine uses the `:latest` tag as a default. This example pulls the
`debian:latest` image:
$ docker image pull debian $ docker image pull debian
Using default tag: latest Using default tag: latest
latest: Pulling from library/debian latest: Pulling from library/debian
fdd5d7827f33: Pull complete e756f3fdd6a3: Pull complete
a3ed95caeb02: Pull complete Digest: sha256:3f1d6c17773a45c97bd8f158d665c9709d7b29ed7917ac934086ad96f92e4510
Digest: sha256:e7d38b3517548a1c71e41bffe9c8ae6d6d29546ce46bf62159837aad072c90aa
Status: Downloaded newer image for debian:latest Status: Downloaded newer image for debian:latest
docker.io/library/debian:latest
Docker images can consist of multiple layers. In the example above, the image Docker images can consist of multiple layers. In the example above, the image
consists of two layers; `fdd5d7827f33` and `a3ed95caeb02`. consists of a single layer; `e756f3fdd6a3`.
Layers can be reused by images. For example, the `debian:jessie` image shares Layers can be reused by images. For example, the `debian:bullseye` image shares
both layers with `debian:latest`. Pulling the `debian:jessie` image therefore its layer with the `debian:latest`. Pulling the `debian:bullseye` image therefore
only pulls its metadata, but not its layers, because all layers are already only pulls its metadata, but not its layers, because the layer is already present
present locally: locally:
$ docker image pull debian:jessie $ docker image pull debian:bullseye
jessie: Pulling from library/debian bullseye: Pulling from library/debian
fdd5d7827f33: Already exists Digest: sha256:3f1d6c17773a45c97bd8f158d665c9709d7b29ed7917ac934086ad96f92e4510
a3ed95caeb02: Already exists Status: Downloaded newer image for debian:bullseye
Digest: sha256:a9c958be96d7d40df920e7041608f2f017af81800ca5ad23e327bc402626b58e docker.io/library/debian:bullseye
Status: Downloaded newer image for debian:jessie
To see which images are present locally, use the **docker-images(1)** To see which images are present locally, use the **docker-images(1)**
command: command:
@ -45,18 +45,17 @@ command:
$ docker images $ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE REPOSITORY TAG IMAGE ID CREATED SIZE
debian jessie f50f9524513f 5 days ago 125.1 MB debian bullseye 4eacea30377a 8 days ago 124MB
debian latest f50f9524513f 5 days ago 125.1 MB debian latest 4eacea30377a 8 days ago 124MB
Docker uses a content-addressable image store, and the image ID is a SHA256 Docker uses a content-addressable image store, and the image ID is a SHA256
digest covering the image's configuration and layers. In the example above, digest covering the image's configuration and layers. In the example above,
`debian:jessie` and `debian:latest` have the same image ID because they are `debian:bullseye` and `debian:latest` have the same image ID because they are
actually the *same* image tagged with different names. Because they are the the *same* image tagged with different names. Because they are the same image,
same image, their layers are stored only once and do not consume extra disk their layers are stored only once and do not consume extra disk space.
space.
For more information about images, layers, and the content-addressable store, For more information about images, layers, and the content-addressable store,
refer to [about storage drivers](https://docs.docker.com/storage/storagedriver/) refer to [understand images, containers, and storage drivers](https://docs.docker.com/storage/storagedriver/)
in the online documentation. in the online documentation.
@ -65,8 +64,8 @@ in the online documentation.
So far, you've pulled images by their name (and "tag"). Using names and tags is So far, you've pulled images by their name (and "tag"). Using names and tags is
a convenient way to work with images. When using tags, you can `docker image pull` an a convenient way to work with images. When using tags, you can `docker image pull` an
image again to make sure you have the most up-to-date version of that image. image again to make sure you have the most up-to-date version of that image.
For example, `docker image pull ubuntu:14.04` pulls the latest version of the Ubuntu For example, `docker image pull ubuntu:22.04` pulls the latest version of the Ubuntu
14.04 image. 22.04 image.
In some cases you don't want images to be updated to newer versions, but prefer In some cases you don't want images to be updated to newer versions, but prefer
to use a fixed version of an image. Docker enables you to pull an image by its to use a fixed version of an image. Docker enables you to pull an image by its
@ -75,22 +74,20 @@ of an image to pull. Doing so, allows you to "pin" an image to that version,
and guarantee that the image you're using is always the same. and guarantee that the image you're using is always the same.
To know the digest of an image, pull the image first. Let's pull the latest To know the digest of an image, pull the image first. Let's pull the latest
`ubuntu:14.04` image from Docker Hub: `ubuntu:22.04` image from Docker Hub:
$ docker image pull ubuntu:14.04 $ docker image pull ubuntu:22.04
14.04: Pulling from library/ubuntu 22.04: Pulling from library/ubuntu
5a132a7e7af1: Pull complete 125a6e411906: Pull complete
fd2731e4c50c: Pull complete Digest: sha256:26c68657ccce2cb0a31b330cb0be2b5e108d467f641c62e13ab40cbec258c68d
28a2f68d1120: Pull complete Status: Downloaded newer image for ubuntu:22.04
a3ed95caeb02: Pull complete docker.io/library/ubuntu:22.04
Digest: sha256:45b23dee08af5e43a7fea6c4cf9c25ccf269ee113168c19722f87876677c5cb2
Status: Downloaded newer image for ubuntu:14.04
Docker prints the digest of the image after the pull has finished. In the example Docker prints the digest of the image after the pull has finished. In the example
above, the digest of the image is: above, the digest of the image is:
sha256:45b23dee08af5e43a7fea6c4cf9c25ccf269ee113168c19722f87876677c5cb2 sha256:26c68657ccce2cb0a31b330cb0be2b5e108d467f641c62e13ab40cbec258c68d
Docker also prints the digest of an image when *pushing* to a registry. This Docker also prints the digest of an image when *pushing* to a registry. This
may be useful if you want to pin to a version of the image you just pushed. may be useful if you want to pin to a version of the image you just pushed.
@ -98,27 +95,26 @@ may be useful if you want to pin to a version of the image you just pushed.
A digest takes the place of the tag when pulling an image, for example, to A digest takes the place of the tag when pulling an image, for example, to
pull the above image by digest, run the following command: pull the above image by digest, run the following command:
$ docker image pull ubuntu@sha256:45b23dee08af5e43a7fea6c4cf9c25ccf269ee113168c19722f87876677c5cb2 $ docker image pull ubuntu@sha256:26c68657ccce2cb0a31b330cb0be2b5e108d467f641c62e13ab40cbec258c68d
sha256:45b23dee08af5e43a7fea6c4cf9c25ccf269ee113168c19722f87876677c5cb2: Pulling from library/ubuntu docker.io/library/ubuntu@sha256:26c68657ccce2cb0a31b330cb0be2b5e108d467f641c62e13ab40cbec258c68d: Pulling from library/ubuntu
5a132a7e7af1: Already exists Digest: sha256:26c68657ccce2cb0a31b330cb0be2b5e108d467f641c62e13ab40cbec258c68d
fd2731e4c50c: Already exists Status: Image is up to date for ubuntu@sha256:26c68657ccce2cb0a31b330cb0be2b5e108d467f641c62e13ab40cbec258c68d
28a2f68d1120: Already exists docker.io/library/ubuntu@sha256:26c68657ccce2cb0a31b330cb0be2b5e108d467f641c62e13ab40cbec258c68d
a3ed95caeb02: Already exists
Digest: sha256:45b23dee08af5e43a7fea6c4cf9c25ccf269ee113168c19722f87876677c5cb2
Status: Downloaded newer image for ubuntu@sha256:45b23dee08af5e43a7fea6c4cf9c25ccf269ee113168c19722f87876677c5cb2
Digest can also be used in the `FROM` of a Dockerfile, for example: Digest can also be used in the `FROM` of a Dockerfile, for example:
FROM ubuntu@sha256:45b23dee08af5e43a7fea6c4cf9c25ccf269ee113168c19722f87876677c5cb2 FROM ubuntu@sha256:26c68657ccce2cb0a31b330cb0be2b5e108d467f641c62e13ab40cbec258c68d
LABEL org.opencontainers.image.authors="some maintainer <maintainer@example.com>" LABEL org.opencontainers.image.authors="some maintainer <maintainer@example.com>"
> **Note**: Using this feature "pins" an image to a specific version in time. > **Note**
> Docker will therefore not pull updated versions of an image, which may include >
> Using this feature "pins" an image to a specific version in time.
> Docker does therefore not pull updated versions of an image, which may include
> security updates. If you want to pull an updated image, you need to change the > security updates. If you want to pull an updated image, you need to change the
> digest accordingly. > digest accordingly.
## Pulling from a different registry ## Pull from a different registry
By default, `docker image pull` pulls images from Docker Hub. It is also possible to By default, `docker image pull` pulls images from Docker Hub. It is also possible to
manually specify the path of a registry to pull from. For example, if you have manually specify the path of a registry to pull from. For example, if you have
@ -144,46 +140,48 @@ By default, `docker image pull` pulls a *single* image from the registry. A repo
can contain multiple images. To pull all images from a repository, provide the can contain multiple images. To pull all images from a repository, provide the
`-a` (or `--all-tags`) option when using `docker image pull`. `-a` (or `--all-tags`) option when using `docker image pull`.
This command pulls all images from the `fedora` repository: This command pulls all images from the `ubuntu` repository:
$ docker image pull --all-tags fedora $ docker image pull --all-tags ubuntu
Pulling repository fedora Pulling repository ubuntu
ad57ef8d78d7: Download complete ad57ef8d78d7: Download complete
105182bb5e8b: Download complete 105182bb5e8b: Download complete
511136ea3c5a: Download complete 511136ea3c5a: Download complete
73bd853d2ea5: Download complete 73bd853d2ea5: Download complete
.... ....
Status: Downloaded newer image for fedora Status: Downloaded newer image for ubuntu
After the pull has completed use the `docker images` command to see the After the pull has completed use the `docker image ls` (or `docker images` shorthand)
images that were pulled. The example below shows all the `fedora` images command to see the images that were pulled. The example below shows all the `ubuntu`
that are present locally: images that are present locally:
$ docker images fedora
$ docker image ls --filter reference=ubuntu
REPOSITORY TAG IMAGE ID CREATED SIZE REPOSITORY TAG IMAGE ID CREATED SIZE
fedora rawhide ad57ef8d78d7 5 days ago 359.3 MB ubuntu 18.04 c6ad7e71ba7d 5 weeks ago 63.2MB
fedora 20 105182bb5e8b 5 days ago 372.7 MB ubuntu bionic c6ad7e71ba7d 5 weeks ago 63.2MB
fedora heisenbug 105182bb5e8b 5 days ago 372.7 MB ubuntu 22.04 5ccefbfc0416 2 months ago 78MB
fedora latest 105182bb5e8b 5 days ago 372.7 MB ubuntu focal ff0fea8310f3 2 months ago 72.8MB
ubuntu latest ff0fea8310f3 2 months ago 72.8MB
ubuntu jammy 41ba606c8ab9 3 months ago 79MB
ubuntu 20.04 ba6acccedd29 7 months ago 72.8MB
...
## Cancel a pull
## Canceling a pull
Killing the `docker image pull` process, for example by pressing `CTRL-c` while it is Killing the `docker image pull` process, for example by pressing `CTRL-c` while it is
running in a terminal, will terminate the pull operation. running in a terminal, will terminate the pull operation.
$ docker image pull fedora $ docker image pull ubuntu
Using default tag: latest Using default tag: latest
latest: Pulling from library/fedora latest: Pulling from library/ubuntu
a3ed95caeb02: Pulling fs layer a3ed95caeb02: Pulling fs layer
236608c7b546: Pulling fs layer 236608c7b546: Pulling fs layer
^C ^C
> **Note**: Technically, the Engine terminates a pull operation when the The Engine terminates a pull operation when the connection between the Docker
> connection between the Docker Engine daemon and the Docker Engine client Engine daemon and the Docker Engine client initiating the pull is lost. If the
> initiating the pull is lost. If the connection with the Engine daemon is connection with the Engine daemon is lost for other reasons than a manual
> lost for other reasons than a manual interaction, the pull is also aborted. interaction, the pull is also aborted.

18
man/src/system/events.md
View File

@ -62,8 +62,8 @@ The following example outputs all events that were generated in the last 3 minut
relative to the current time on the client machine: relative to the current time on the client machine:
# docker events --since '3m' # docker events --since '3m'
2015-05-12T11:51:30.999999999Z07:00 4386fb97867d: (from ubuntu-1:14.04) die 2015-05-12T11:51:30.999999999Z07:00 4386fb97867d: (from ubuntu:22.04) die
2015-05-12T15:52:12.999999999Z07:00 4386fb97867d: (from ubuntu-1:14.04) stop 2015-05-12T15:52:12.999999999Z07:00 4386fb97867d: (from ubuntu:22.04) stop
2015-05-12T15:53:45.999999999Z07:00 7805c1d35632: (from redis:2.8) die 2015-05-12T15:53:45.999999999Z07:00 7805c1d35632: (from redis:2.8) die
2015-05-12T15:54:03.999999999Z07:00 7805c1d35632: (from redis:2.8) stop 2015-05-12T15:54:03.999999999Z07:00 7805c1d35632: (from redis:2.8) stop
@ -97,21 +97,21 @@ Lines. For information about JSON Lines, please refer to http://jsonlines.org/ .
## Filters ## Filters
$ docker events --filter 'event=stop' $ docker events --filter 'event=stop'
2014-05-10T17:42:14.999999999Z07:00 container stop 4386fb97867d (image=ubuntu-1:14.04) 2014-05-10T17:42:14.999999999Z07:00 container stop 4386fb97867d (image=ubuntu:22.04)
2014-09-03T17:42:14.999999999Z07:00 container stop 7805c1d35632 (image=redis:2.8) 2014-09-03T17:42:14.999999999Z07:00 container stop 7805c1d35632 (image=redis:2.8)
$ docker events --filter 'image=ubuntu-1:14.04' $ docker events --filter 'image=ubuntu:22.04'
2014-05-10T17:42:14.999999999Z07:00 container start 4386fb97867d (image=ubuntu-1:14.04) 2014-05-10T17:42:14.999999999Z07:00 container start 4386fb97867d (image=ubuntu:22.04)
2014-05-10T17:42:14.999999999Z07:00 container die 4386fb97867d (image=ubuntu-1:14.04) 2014-05-10T17:42:14.999999999Z07:00 container die 4386fb97867d (image=ubuntu:22.04)
2014-05-10T17:42:14.999999999Z07:00 container stop 4386fb97867d (image=ubuntu-1:14.04) 2014-05-10T17:42:14.999999999Z07:00 container stop 4386fb97867d (image=ubuntu:22.04)
$ docker events --filter 'container=7805c1d35632' $ docker events --filter 'container=7805c1d35632'
2014-05-10T17:42:14.999999999Z07:00 container die 7805c1d35632 (image=redis:2.8) 2014-05-10T17:42:14.999999999Z07:00 container die 7805c1d35632 (image=redis:2.8)
2014-09-03T15:49:29.999999999Z07:00 container stop 7805c1d35632 (image= redis:2.8) 2014-09-03T15:49:29.999999999Z07:00 container stop 7805c1d35632 (image= redis:2.8)
$ docker events --filter 'container=7805c1d35632' --filter 'container=4386fb97867d' $ docker events --filter 'container=7805c1d35632' --filter 'container=4386fb97867d'
2014-09-03T15:49:29.999999999Z07:00 container die 4386fb97867d (image=ubuntu-1:14.04) 2014-09-03T15:49:29.999999999Z07:00 container die 4386fb97867d (image=ubuntu:22.04)
2014-05-10T17:42:14.999999999Z07:00 container stop 4386fb97867d (image=ubuntu-1:14.04) 2014-05-10T17:42:14.999999999Z07:00 container stop 4386fb97867d (image=ubuntu:22.04)
2014-05-10T17:42:14.999999999Z07:00 container die 7805c1d35632 (image=redis:2.8) 2014-05-10T17:42:14.999999999Z07:00 container die 7805c1d35632 (image=redis:2.8)
2014-09-03T15:49:29.999999999Z07:00 container stop 7805c1d35632 (image=redis:2.8) 2014-09-03T15:49:29.999999999Z07:00 container stop 7805c1d35632 (image=redis:2.8)

153
man/src/system/info.md
View File

@ -20,148 +20,77 @@ available on the volume where `/var/lib/docker` is mounted.
## Display Docker system information ## Display Docker system information
Here is a sample output for a daemon running on Ubuntu, using the overlay2 The example below shows the output for a daemon running on Ubuntu Linux,
storage driver: using the `overlay2` storage driver. As can be seen in the output, additional
information about the `overlay2` storage driver is shown:
$ docker -D info ```console
Client: $ docker info
Debug Mode: true
Server: Client:
Context: default
Debug Mode: false
Plugins:
buildx: Docker Buildx (Docker Inc.)
Version: v0.8.2
Path: /usr/libexec/docker/cli-plugins/docker-buildx
compose: Docker Compose (Docker Inc.)
Version: v2.6.0
Path: /usr/libexec/docker/cli-plugins/docker-compose
scan: Docker Scan (Docker Inc.)
Version: v0.17.0
Path: /usr/libexec/docker/cli-plugins/docker-scan
Server:
Containers: 14 Containers: 14
Running: 3 Running: 3
Paused: 1 Paused: 1
Stopped: 10 Stopped: 10
Images: 52 Images: 52
Server Version: 1.13.0 Server Version: 22.06.0
Storage Driver: overlay2 Storage Driver: overlay2
Backing Filesystem: extfs Backing Filesystem: extfs
Supports d_type: true Supports d_type: true
Native Overlay Diff: false Using metacopy: false
Native Overlay Diff: true
userxattr: false
Logging Driver: json-file Logging Driver: json-file
Cgroup Driver: cgroupfs Cgroup Driver: systemd
Cgroup Version: 2
Plugins: Plugins:
Volume: local Volume: local
Network: bridge host macvlan null overlay Network: bridge host ipvlan macvlan null overlay
Swarm: active Log: awslogs fluentd gcplogs gelf journald json-file local logentries splunk syslog
NodeID: rdjq45w1op418waxlairloqbm Swarm: inactive
Is Manager: true Runtimes: io.containerd.runc.v2 io.containerd.runtime.v1.linux runc
ClusterID: te8kdyw33n36fqiz74bfjeixd
Managers: 1
Nodes: 2
Orchestration:
Task History Retention Limit: 5
Raft:
Snapshot Interval: 10000
Number of Old Snapshots to Retain: 0
Heartbeat Tick: 1
Election Tick: 3
Dispatcher:
Heartbeat Period: 5 seconds
CA Configuration:
Expiry Duration: 3 months
Node Address: 172.16.66.128 172.16.66.129
Manager Addresses:
172.16.66.128:2477
Runtimes: runc
Default Runtime: runc Default Runtime: runc
Init Binary: docker-init Init Binary: docker-init
containerd version: 8517738ba4b82aff5662c97ca4627e7e4d03b531 containerd version: 212e8b6fa2f44b9c21b2798135fc6fb7c53efc16
runc version: ac031b5bf1cc92239461125f4c1ffb760522bbf2 runc version: v1.1.1-0-g52de29d
init version: N/A (expected: v0.13.0) init version: de40ad0
Security Options: Security Options:
apparmor apparmor
seccomp seccomp
Profile: default Profile: builtin
Kernel Version: 4.4.0-31-generic cgroupns
Operating System: Ubuntu 16.04.1 LTS Kernel Version: 5.15.0-25-generic
OSType: linux Operating System: Ubuntu 22.04 LTS
Architecture: x86_64
CPUs: 2
Total Memory: 1.937 GiB
Name: ubuntu
ID: H52R:7ZR6:EIIA:76JG:ORIY:BVKF:GSFU:HNPG:B5MK:APSC:SZ3Q:N326
Docker Root Dir: /var/lib/docker
Debug Mode: true
File Descriptors: 30
Goroutines: 123
System Time: 2016-11-12T17:24:37.955404361-08:00
EventsListeners: 0
Http Proxy: http://test:test@proxy.example.com:8080
Https Proxy: https://test:test@proxy.example.com:8080
No Proxy: localhost,127.0.0.1,docker-registry.somecorporation.com
Registry: https://index.docker.io/v1/
WARNING: No swap limit support
Labels:
storage=ssd
staging=true
Experimental: false
Insecure Registries:
127.0.0.0/8
Registry Mirrors:
http://192.168.1.2/
http://registry-mirror.example.com:5000/
Live Restore Enabled: false
The global `-D` option tells all `docker` commands to output debug information.
The example below shows the output for a daemon running on Red Hat Enterprise Linux,
using the devicemapper storage driver. As can be seen in the output, additional
information about the devicemapper storage driver is shown:
$ docker info
Client:
Debug Mode: false
Server:
Containers: 14
Running: 3
Paused: 1
Stopped: 10
Untagged Images: 52
Server Version: 1.10.3
Storage Driver: devicemapper
Pool Name: docker-202:2-25583803-pool
Pool Blocksize: 65.54 kB
Base Device Size: 10.74 GB
Backing Filesystem: xfs
Data file: /dev/loop0
Metadata file: /dev/loop1
Data Space Used: 1.68 GB
Data Space Total: 107.4 GB
Data Space Available: 7.548 GB
Metadata Space Used: 2.322 MB
Metadata Space Total: 2.147 GB
Metadata Space Available: 2.145 GB
Udev Sync Supported: true
Deferred Removal Enabled: false
Deferred Deletion Enabled: false
Deferred Deleted Device Count: 0
Data loop file: /var/lib/docker/devicemapper/devicemapper/data
Metadata loop file: /var/lib/docker/devicemapper/devicemapper/metadata
Library Version: 1.02.107-RHEL7 (2015-12-01)
Execution Driver: native-0.2
Logging Driver: json-file
Plugins:
Volume: local
Network: null host bridge
Kernel Version: 3.10.0-327.el7.x86_64
Operating System: Red Hat Enterprise Linux Server 7.2 (Maipo)
OSType: linux OSType: linux
Architecture: x86_64 Architecture: x86_64
CPUs: 1 CPUs: 1
Total Memory: 991.7 MiB Total Memory: 991.7 MiB
Name: ip-172-30-0-91.ec2.internal Name: ip-172-30-0-91.ec2.internal
ID: I54V:OLXT:HVMM:TPKO:JPHQ:CQCD:JNLC:O3BZ:4ZVJ:43XJ:PFHZ:6N2S ID: 4cee4408-10d2-4e17-891c-a41736ac4536
Docker Root Dir: /var/lib/docker Docker Root Dir: /var/lib/docker
Debug Mode: false Debug Mode: false
Username: gordontheturtle Username: gordontheturtle
Registry: https://index.docker.io/v1/ Registry: https://index.docker.io/v1/
Experimental: false
Insecure registries: Insecure registries:
myinsecurehost:5000 myinsecurehost:5000
127.0.0.0/8 127.0.0.0/8
Live Restore Enabled: false
```
You can also specify the output format: You can also specify the output format: