6 S SK J r SSKJr SSKJr SSKJr SSKJr SSKJr SSKJ r SS KJ
r
SS
KJ r " S S 5 r g
) )datetime )errors)utils)DEFAULT_DATA_CHUNK_SIZE)CancellableStream)ContainerConfig)EndpointConfig)
HostConfigNetworkingConfigc d \ rS rSr\R
" S5 S'S j5 r\R
" S5 S(S j5 r\R
" S5 S)S j5 r S*S jr S+S jr
S
r S,S jr S r
S
rS r\R
" S5 S 5 r\R
" S5 \4S j5 r\R
" S5 \S4S j5 r\R
" S5 S 5 r\R
" S5 S-S j5 r\R
" S5 S.S j5 r\R
" S5 S 5 r\R
" S5 S 5 r\R
" S5 S 5 r\R4 " S5 S-S j5 r\R
" S5 S/S j5 r \R
" S5 S 5 r \R
" S5 S 5 r \R
" S5 S0S j5 r \R
" S5 S 5 r \R
" S5 S1S j5 r!\R
" S5 S-S j5 r"\R
" S5 S-S! j5 r#\R
" S5 S" 5 r$\R4 " S#5 \R
" S5 S2S$ j5 5 r%\R
" S5 S,S% j5 r&S&r'g)3ContainerApiMixin
containerFc X U=( a S=( d SU=( a S=( d SU=( a S=( d SU=( a S=( d SS.nSSS.nU R SU5 n U R XUSS 9n
U R XU R U5 US
9n U( a [ X5 $ U $ ) a
Attach to a container.
The ``.logs()`` function is a wrapper around this method, which you can
use instead if you want to fetch/stream container output without first
retrieving the entire backlog.
Args:
container (str): The container to attach to.
stdout (bool): Include stdout.
stderr (bool): Include stderr.
stream (bool): Return container output progressively as an iterator
of strings, rather than a single string.
logs (bool): Include the container's previous output.
demux (bool): Keep stdout and stderr separate.
Returns:
By default, the container's output as a single string (two if
``demux=True``: one for stdout and one for stderr).
If ``stream=True``, an iterator of output strings. If
``demux=True``, two iterators are returned: one for stdout and one
for stderr.
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
r )logsstdoutstderrstreamUpgradetcp
Connectionr /containers/{0}/attachT)headersparamsr )demux)_url_post_read_from_socket
_check_is_ttyr ) selfr r r r r r r r uresponseoutputs 'lib/third_party/docker/api/container.pyattachContainerApiMixin.attach s @ JQO! l'a l'a l'a
$
II. :::a:M'' d 0 0 ;5 ( J $V6 6M Nc
$ Uc SSSS.nSU; a" SU R ; a U R S US' U( a U R X5 $ SSS.nU R SU5 nU R U R USU R U5 S US
95 $ ) a
Like ``attach``, but returns the underlying socket-like object for the
HTTP request.
Args:
container (str): The container to attach to.
params (dict): Dictionary of request parameters (e.g. ``stdout``,
``stderr``, ``stream``).
For ``detachKeys``, ~/.docker/config.json is used by default.
ws (bool): Use websockets instead of raw HTTP.
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
Nr )r r r
detachKeysr r r r Tr r r )_general_configs_attach_websocketr _get_raw_response_socketpost_attach_params)r$ r r wsr r% s r(
attach_socket ContainerApiMixin.attach_socketD s " >F v % D$9$99#'#8#8 #FF<
)))< < $
II. :,, II4 3 3F ;D
r+ c r UUUUUUS.nU R S5 n U R U R XUS9SS9$ )a
Commit a container to an image. Similar to the ``docker commit``
command.
Args:
container (str): The image hash of the container
repository (str): The repository to push the image to
tag (str): The tag to push
message (str): A commit message
author (str): The name of the author
changes (str): Dockerfile instructions to apply while committing
conf (dict): The configuration for the container. See the
`Engine API documentation
`_
for full details.
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
)r repotagcommentauthorchangesz/commitdatar Tjson)r _result
_post_json)
r$ r
repositoryr9 messager; r< confr r% s
r( commitContainerApiMixin.commitq sU 0 #
IIi || OOAO 8t
r+ c
~ U( a SOUU( a SOSU( a SOSU( a SOSUUS.n
U ( a [ R " U 5 U
S' U R S5 n U R U R XS9S5 n U( a U V
s/ s H
n
SU
S 0PM sn
$ U( a U H n
U
S S S
U
S' M U $ s sn
f ) a
List containers. Similar to the ``docker ps`` command.
Args:
quiet (bool): Only display numeric Ids
all (bool): Show all containers. Only running containers are shown
by default
trunc (bool): Truncate output
latest (bool): Show only the latest created container, include
non-running ones.
since (str): Show only containers created since Id or Name, include
non-running ones
before (str): Show only container created before Id or Name,
include non-running ones
limit (int): Show `limit` last created containers, include
non-running ones
size (bool): Display sizes
filters (dict): Filters to be processed on the image list.
Available filters:
- `exited` (int): Only containers with specified exit code
- `status` (str): One of ``restarting``, ``running``,
``paused``, ``exited``
- `label` (str|list): format either ``"key"``, ``"key=value"``
or a list of such.
- `id` (str): The id of the container.
- `name` (str): The name of the container.
- `ancestor` (str): Filter by container ancestor. Format of
``[:tag]``, ````, or
````.
- `before` (str): Only containers created before a particular
container. Give the container name or id.
- `since` (str): Only containers created after a particular
container. Give container name or id.
A comprehensive list can be found in the documentation for
`docker ps
`_.
Returns:
A list of dicts, one per container
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
r r )limitallsize trunc_cmdsincebeforefiltersz/containers/jsonr TIdN )r convert_filtersr rA _get)r$ quietrJ trunclatestrM rN rI rK rO r r% resxs r(
containers ContainerApiMixin.containers s d !Qe1 A1 #
% 5 5g >F9 II( )ll499Q96= -01ST1T7OS1 1 D'#2,$
2s B:c V [ U
[ 5 ( a U
/n
[ U [ 5 ( a [ R R U 5 n U( a$ U R
R
U 5 =( d Sn U R XX4XVUXU
XXUUUUUUUU5 nU R UU U5 $ )a
Creates a container. Parameters are similar to those for the ``docker
run`` command except it doesn't support the attach options (``-a``).
The arguments that are passed directly to this function are
host-independent configuration options. Host-specific configuration
is passed with the `host_config` argument. You'll normally want to
use this method in combination with the :py:meth:`create_host_config`
method to generate ``host_config``.
**Port bindings**
Port binding is done in two parts: first, provide a list of ports to
open inside the container with the ``ports`` parameter, then declare
bindings with the ``host_config`` parameter. For example:
.. code-block:: python
container_id = client.api.create_container(
'busybox', 'ls', ports=[1111, 2222],
host_config=client.api.create_host_config(port_bindings={
1111: 4567,
2222: None
})
)
You can limit the host address on which the port will be exposed like
such:
.. code-block:: python
client.api.create_host_config(
port_bindings={1111: ('127.0.0.1', 4567)}
)
Or without host port assignment:
.. code-block:: python
client.api.create_host_config(port_bindings={1111: ('127.0.0.1',)})
If you wish to use UDP instead of TCP (default), you need to declare
ports as such in both the config and host config:
.. code-block:: python
container_id = client.api.create_container(
'busybox', 'ls', ports=[(1111, 'udp'), 2222],
host_config=client.api.create_host_config(port_bindings={
'1111/udp': 4567, 2222: None
})
)
To bind multiple host ports to a single container port, use the
following syntax:
.. code-block:: python
client.api.create_host_config(port_bindings={
1111: [1234, 4567]
})
You can also bind multiple IPs to a single container port:
.. code-block:: python
client.api.create_host_config(port_bindings={
1111: [
('192.168.0.100', 1234),
('192.168.0.101', 1234)
]
})
**Using volumes**
Volume declaration is done in two parts. Provide a list of
paths to use as mountpoints inside the container with the
``volumes`` parameter, and declare mappings from paths on the host
in the ``host_config`` section.
.. code-block:: python
container_id = client.api.create_container(
'busybox', 'ls', volumes=['/mnt/vol1', '/mnt/vol2'],
host_config=client.api.create_host_config(binds={
'/home/user1/': {
'bind': '/mnt/vol2',
'mode': 'rw',
},
'/var/www': {
'bind': '/mnt/vol1',
'mode': 'ro',
}
})
)
You can alternatively specify binds as a list. This code is equivalent
to the example above:
.. code-block:: python
container_id = client.api.create_container(
'busybox', 'ls', volumes=['/mnt/vol1', '/mnt/vol2'],
host_config=client.api.create_host_config(binds=[
'/home/user1/:/mnt/vol2',
'/var/www:/mnt/vol1:ro',
])
)
**Networking**
You can specify networks to connect the container to by using the
``networking_config`` parameter. At the time of creation, you can
only connect a container to a single networking, but you
can create more connections by using
:py:meth:`~connect_container_to_network`.
For example:
.. code-block:: python
networking_config = client.api.create_networking_config({
'network1': client.api.create_endpoint_config(
ipv4_address='172.28.0.124',
aliases=['foo', 'bar'],
links=['container2']
)
})
ctnr = client.api.create_container(
img, command, networking_config=networking_config
)
Args:
image (str): The image to run
command (str or list): The command to be run in the container
hostname (str): Optional hostname for the container
user (str or int): Username or UID
detach (bool): Detached mode: run container in the background and
return container ID
stdin_open (bool): Keep STDIN open even if not attached
tty (bool): Allocate a pseudo-TTY
ports (list of ints): A list of port numbers
environment (dict or list): A dictionary or a list of strings in
the following format ``["PASSWORD=xxx"]`` or
``{"PASSWORD": "xxx"}``.
volumes (str or list): List of paths inside the container to use
as volumes.
network_disabled (bool): Disable networking
name (str): A name for the container
entrypoint (str or list): An entrypoint
working_dir (str): Path to the working directory
domainname (str): The domain name to use for the container
host_config (dict): A dictionary created with
:py:meth:`create_host_config`.
mac_address (str): The Mac Address to assign the container
labels (dict or list): A dictionary of name-value labels (e.g.
``{"label1": "value1", "label2": "value2"}``) or a list of
names of labels to set with empty values (e.g.
``["label1", "label2"]``)
stop_signal (str): The stop signal to use to stop the container
(e.g. ``SIGINT``).
stop_timeout (int): Timeout to stop the container, in seconds.
Default: 10
networking_config (dict): A networking configuration generated
by :py:meth:`create_networking_config`.
runtime (str): Runtime to use with this container.
healthcheck (dict): Specify a test to perform to check that the
container is healthy.
use_config_proxy (bool): If ``True``, and if the docker client
configuration file (``~/.docker/config.json`` by default)
contains a proxy configuration, the corresponding environment
variables will be set in the container being created.
platform (str): Platform in the format ``os[/arch[/variant]]``.
Returns:
A dictionary with an image 'Id' key and a 'Warnings' key.
Raises:
:py:class:`docker.errors.ImageNotFound`
If the specified image does not exist.
:py:class:`docker.errors.APIError`
If the server returns an error.
N)
isinstancestrdictr format_environment_proxy_configsinject_proxy_environmentcreate_container_config create_container_from_config)r$ imagecommandhostnameuserdetach
stdin_openttyports environmentvolumesnetwork_disabledname
entrypoint working_dir
domainname host_config mac_addresslabels stop_signalnetworking_config healthcheck stop_timeoutruntimeuse_config_proxyplatformconfigs r( create_container"ContainerApiMixin.create_container s D gs # # kG k4 ( ( ++88EK --FF
-- HF + f *K '
00xHHr+ c 4 [ U R /UQ70 UD6$ N)r _versionr$ argskwargss r( rc )ContainerApiMixin.create_container_config s t}}>t>v>>r+ c U R S5 nSU0nU( a@ [ R " U R S5 ( a [ R
" S5 eX5S' U R
XAUS9nU R US5 $ )Nz/containers/createrp 1.41z0platform is not supported for API version < 1.41r} r= T)r r
version_ltr r InvalidVersionrB rA )r$ r~ rp r} r% r rX s r( rd .ContainerApiMixin.create_container_from_config s| II* + D
v66 ++F "*: ooaVo<||C&&r+ c j U( d 0 nSU; a [ S5 eU R US' [ U0 UD6$ )aT
Create a dictionary for the ``host_config`` argument to
:py:meth:`create_container`.
Args:
auto_remove (bool): enable auto-removal of the container on daemon
side when the container's process exits.
binds (dict): Volumes to bind. See :py:meth:`create_container`
for more information.
blkio_weight_device: Block IO weight (relative device weight) in
the form of: ``[{"Path": "device_path", "Weight": weight}]``.
blkio_weight: Block IO weight (relative weight), accepts a weight
value between 10 and 1000.
cap_add (list of str): Add kernel capabilities. For example,
``["SYS_ADMIN", "MKNOD"]``.
cap_drop (list of str): Drop kernel capabilities.
cpu_period (int): The length of a CPU period in microseconds.
cpu_quota (int): Microseconds of CPU time that the container can
get in a CPU period.
cpu_shares (int): CPU shares (relative weight).
cpuset_cpus (str): CPUs in which to allow execution (``0-3``,
``0,1``).
cpuset_mems (str): Memory nodes (MEMs) in which to allow execution
(``0-3``, ``0,1``). Only effective on NUMA systems.
device_cgroup_rules (:py:class:`list`): A list of cgroup rules to
apply to the container.
device_read_bps: Limit read rate (bytes per second) from a device
in the form of: `[{"Path": "device_path", "Rate": rate}]`
device_read_iops: Limit read rate (IO per second) from a device.
device_write_bps: Limit write rate (bytes per second) from a
device.
device_write_iops: Limit write rate (IO per second) from a device.
devices (:py:class:`list`): Expose host devices to the container,
as a list of strings in the form
``::``.
For example, ``/dev/sda:/dev/xvda:rwm`` allows the container
to have read-write access to the host's ``/dev/sda`` via a
node named ``/dev/xvda`` inside the container.
device_requests (:py:class:`list`): Expose host resources such as
GPUs to the container, as a list of
:py:class:`docker.types.DeviceRequest` instances.
dns (:py:class:`list`): Set custom DNS servers.
dns_opt (:py:class:`list`): Additional options to be added to the
container's ``resolv.conf`` file
dns_search (:py:class:`list`): DNS search domains.
extra_hosts (dict): Additional hostnames to resolve inside the
container, as a mapping of hostname to IP address.
group_add (:py:class:`list`): List of additional group names and/or
IDs that the container process will run as.
init (bool): Run an init inside the container that forwards
signals and reaps processes
ipc_mode (str): Set the IPC mode for the container.
isolation (str): Isolation technology to use. Default: ``None``.
links (dict): Mapping of links using the
``{'container': 'alias'}`` format. The alias is optional.
Containers declared in this dict will be linked to the new
container using the provided alias. Default: ``None``.
log_config (LogConfig): Logging configuration
lxc_conf (dict): LXC config.
mem_limit (float or str): Memory limit. Accepts float values
(which represent the memory limit of the created container in
bytes) or a string with a units identification char
(``100000b``, ``1000k``, ``128m``, ``1g``). If a string is
specified without a units character, bytes are assumed as an
mem_reservation (float or str): Memory soft limit.
mem_swappiness (int): Tune a container's memory swappiness
behavior. Accepts number between 0 and 100.
memswap_limit (str or int): Maximum amount of memory + swap a
container is allowed to consume.
mounts (:py:class:`list`): Specification for mounts to be added to
the container. More powerful alternative to ``binds``. Each
item in the list is expected to be a
:py:class:`docker.types.Mount` object.
network_mode (str): One of:
- ``bridge`` Create a new network stack for the container on
the bridge network.
- ``none`` No networking for this container.
- ``container:`` Reuse another container's network
stack.
- ``host`` Use the host network stack.
This mode is incompatible with ``port_bindings``.
oom_kill_disable (bool): Whether to disable OOM killer.
oom_score_adj (int): An integer value containing the score given
to the container in order to tune OOM killer preferences.
pid_mode (str): If set to ``host``, use the host PID namespace
inside the container.
pids_limit (int): Tune a container's pids limit. Set ``-1`` for
unlimited.
port_bindings (dict): See :py:meth:`create_container`
for more information.
Imcompatible with ``host`` in ``network_mode``.
privileged (bool): Give extended privileges to this container.
publish_all_ports (bool): Publish all ports to the host.
read_only (bool): Mount the container's root filesystem as read
only.
restart_policy (dict): Restart the container when it exits.
Configured as a dictionary with keys:
- ``Name`` One of ``on-failure``, or ``always``.
- ``MaximumRetryCount`` Number of times to restart the
container on failure.
security_opt (:py:class:`list`): A list of string values to
customize labels for MLS systems, such as SELinux.
shm_size (str or int): Size of /dev/shm (e.g. ``1G``).
storage_opt (dict): Storage driver options per container as a
key-value mapping.
sysctls (dict): Kernel parameters to set in the container.
tmpfs (dict): Temporary filesystems to mount, as a dictionary
mapping a path inside the container to options for that path.
For example:
.. code-block:: python
{
'/mnt/vol2': '',
'/mnt/vol1': 'size=3G,uid=1000'
}
ulimits (:py:class:`list`): Ulimits to set inside the container,
as a list of :py:class:`docker.types.Ulimit` instances.
userns_mode (str): Sets the user namespace mode for the container
when user namespace remapping option is enabled. Supported
values are: ``host``
uts_mode (str): Sets the UTS namespace mode for the container.
Supported values are: ``host``
volumes_from (:py:class:`list`): List of container names or IDs to
get volumes from.
runtime (str): Runtime to use with this container.
Returns:
(dict) A dictionary which can be passed to the ``host_config``
argument to :py:meth:`create_container`.
Example:
>>> client.api.create_host_config(
... privileged=True,
... cap_drop=['MKNOD'],
... volumes_from=['nostalgic_newton'],
... )
{'CapDrop': ['MKNOD'], 'LxcConf': None, 'Privileged': True,
'VolumesFrom': ['nostalgic_newton'], 'PublishAllPorts': False}
versionzAcreate_host_config() got an unexpected keyword argument 'version') TypeErrorr r r s r( create_host_config$ContainerApiMixin.create_host_config sG l F -
!MMy4*6**r+ c [ U0 UD6$ )aq
Create a networking config dictionary to be used as the
``networking_config`` parameter in :py:meth:`create_container`.
Args:
endpoints_config (dict): A dictionary mapping network names to
endpoint configurations generated by
:py:meth:`create_endpoint_config`.
Returns:
(dict) A networking config.
Example:
>>> client.api.create_network('network1')
>>> networking_config = client.api.create_networking_config({
'network1': client.api.create_endpoint_config()
})
>>> container = client.api.create_container(
img, command, networking_config=networking_config
)
r r s r( create_networking_config*ContainerApiMixin.create_networking_configb s 0 000r+ c 4 [ U R /UQ70 UD6$ )a
Create an endpoint config dictionary to be used with
:py:meth:`create_networking_config`.
Args:
aliases (:py:class:`list`): A list of aliases for this endpoint.
Names in that list can be used within the network to reach the
container. Defaults to ``None``.
links (dict): Mapping of links for this endpoint using the
``{'container': 'alias'}`` format. The alias is optional.
Containers declared in this dict will be linked to this
container using the provided alias. Defaults to ``None``.
ipv4_address (str): The IP address of this container on the
network, using the IPv4 protocol. Defaults to ``None``.
ipv6_address (str): The IP address of this container on the
network, using the IPv6 protocol. Defaults to ``None``.
link_local_ips (:py:class:`list`): A list of link-local (IPv4/IPv6)
addresses.
driver_opt (dict): A dictionary of options to provide to the
network driver. Defaults to ``None``.
Returns:
(dict) An endpoint config.
Example:
>>> endpoint_config = client.api.create_endpoint_config(
aliases=['web', 'app'],
links={'app_db': 'db', 'another': None},
ipv4_address='132.65.0.123'
)
)r
r r s r( create_endpoint_config(ContainerApiMixin.create_endpoint_config| s D dmm=d=f==r+ c d U R U R U R SU5 5 S5 $ )a
Inspect changes on a container's filesystem.
Args:
container (str): The container to diff
Returns:
(list) A list of dictionaries containing the attributes `Path`
and `Kind`.
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
z/containers/{0}/changesTrA rT r r$ r s r( diffContainerApiMixin.diff s/ || IIdii 99E F
r+ c f U R U R SU5 SS9nU R X2S5 $ )a
Export the contents of a filesystem as a tar archive.
Args:
container (str): The container to export
chunk_size (int): The number of bytes returned by each iteration
of the generator. If ``None``, data will be streamed as it is
received. Default: 2 MB
Returns:
(generator): The archived filesystem data stream
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
z/containers/{0}/exportT)r F)rT r _stream_raw_result)r$ r
chunk_sizerX s r( exportContainerApiMixin.export s= $ ii II. :4
&&s>>r+ c * SU0nU( a SS0OSS0nU R SU5 nU R XuSUS9nU R U5 UR R S5 n U R XS 5 U ( a [ R " U 5 4$ S
4$ ) a3
Retrieve a file or folder from a container in the form of a tar
archive.
Args:
container (str): The container where the file is located
path (str): Path to the file or folder to retrieve
chunk_size (int): The number of bytes returned by each iteration
of the generator. If ``None``, data will be streamed as it is
received. Default: 2 MB
encode_stream (bool): Determines if data should be encoded
(gzip-compressed) during transmission. Default: False
Returns:
(tuple): First element is a raw tar data stream. Second element is
a dict containing ``stat`` information on the specified ``path``.
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
Example:
>>> c = docker.APIClient()
>>> f = open('./sh_bin.tar', 'wb')
>>> bits, stat = c.api.get_archive(container, '/bin/sh')
>>> print(stat)
{'name': 'sh', 'size': 1075464, 'mode': 493,
'mtime': '2018-10-01T15:37:48-07:00', 'linkTarget': ''}
>>> for chunk in bits:
... f.write(chunk)
>>> f.close()
pathzAccept-Encodingz
gzip, deflateidentity/containers/{0}/archiveTr. z x-docker-container-path-statFN)r rT _raise_for_statusr getr r decode_json_header)
r$ r r r
encode_streamr r urlrX encoded_stats
r( get_archive ContainerApiMixin.get_archive s J
D
z!
ii19=ii4iI s#{{'EF # #CU ;6BE $ $\ 2
HL
r+ c d U R U R U R SU5 5 S5 $ )a,
Identical to the `docker inspect` command, but only for containers.
Args:
container (str): The container to inspect
Returns:
(dict): Similar to the output of `docker inspect`, but as a
single dict
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
/containers/{0}/jsonTr r s r( inspect_container#ContainerApiMixin.inspect_container s/ || IIdii 6 B CT
r+ c U R SU5 n0 nUb$ [ U[ 5 ( d [ U5 nX$S' U R X4S9nU R U5 g)a
Kill a container or send a signal to a container.
Args:
container (str): The container to kill
signal (str or int): The signal to send. Defaults to ``SIGKILL``
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
z/containers/{0}/killNsignalrP )r r] r^ intr! r )r$ r r r r rX s r( killContainerApiMixin.kill s\ ii. : fc** V %8 jjj, s#r+ c
Uc UnU=( a S=( d SU=( a S=( d SU=( a S=( d SU=( a S=( d SS.n
US:w a [ U[ 5 ( a US: a SnXjS' Ub [ U[ 5 ( a [ R " U5 U
S' On[ U[ 5 ( a US: a XzS' ON[ U[
5 ( a US: a XzS' O.[ R " SR [ U5 5 5 eU b [ R " U R S 5 ( a [ R " S
5 e[ U [ 5 ( a [ R " U 5 U
S ' On[ U [ 5 ( a U S: a XS ' ON[ U [
5 ( a U S: a XS ' O.[ R " S R [ U 5 5 5 eU R S
U5 n U R XUS9n U R XU 5 n
U( a [! X5 $ U
$ )aq
Get logs from a container. Similar to the ``docker logs`` command.
The ``stream`` parameter makes the ``logs`` function return a blocking
generator you can iterate over to retrieve log output as it happens.
Args:
container (str): The container to get logs from
stdout (bool): Get ``STDOUT``. Default ``True``
stderr (bool): Get ``STDERR``. Default ``True``
stream (bool): Stream the response. Default ``False``
timestamps (bool): Show timestamps. Default ``False``
tail (str or int): Output specified number of lines at the end of
logs. Either an integer of number of lines or the string
``all``. Default ``all``
since (datetime, int, or float): Show logs since a given datetime,
integer epoch (in seconds) or float (in fractional seconds)
follow (bool): Follow log output. Default ``False``
until (datetime, int, or float): Show logs that occurred before
the given datetime, integer epoch (in seconds), or
float (in fractional seconds)
Returns:
(generator or str)
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
r r )r r
timestampsfollowrJ tailrM g zF "Lq -A "Lq -A * 0q 5A "Lq -A
5=*T3"7"74!8D v %**"'"="=e"Dw UC((UQY"'w UE**us{"'w ,, #VDK 0
v66 ++C %**"'"="=e"Dw UC((UQY"'w UE**us{"'w ,, #VDK 0
ii. :ii6i:!!)S9 $V1 1Mr+ c l U R SU5 nU R U5 nU R U5 g)z
Pauses all processes within a container.
Args:
container (str): The container to pause
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
z/containers/{0}/pauseNr r! r r$ r r rX s r( pauseContainerApiMixin.pause~ s0 ii/;jjo s#r+ c p U R U R SU5 5 nU R U5 UR 5 n[ U5 nSnUR S0 5 R S5 nUc gSU; a UR U5 $ S H$ nUR US- U- 5 nU( d M# U$ U$ )a
Lookup the public-facing port that is NAT-ed to ``private_port``.
Identical to the ``docker port`` command.
Args:
container (str): The container to look up
private_port (int): The private port to inspect
Returns:
(list of dict): The mapping for the host ports
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
Example:
.. code-block:: bash
$ docker run -d -p 80:80 ubuntu:14.04 /bin/sleep 30
7174d6347063a83f412fad6124c99cffd25ffe1a0807eb4b7f9cec76ac8cb43b
.. code-block:: python
>>> client.api.port('7174d6347063', 80)
[{'HostIp': '0.0.0.0', 'HostPort': '80'}]
r NNetworkSettingsPorts/)r udpsctp)rT r r r@ r^ r )r$ r private_portrX json_h_ports
port_settingsprotocols r( portContainerApiMixin.port s 8 ii "8)DE s#
<( "3R8< )r _putr status_code)r$ r r r> r r rX s r( put_archive ContainerApiMixin.put_archive sM & $ ii19=iii6 s##%%r+ z1.25c 0 nU( a [ R " U5 US' U R S5 nU R U R X2S9S5 $ )a5
Delete stopped containers
Args:
filters (dict): Filters to process on the prune list.
Returns:
(dict): A dict containing a list of deleted container IDs and
the amount of disk space reclaimed in bytes.
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
rO z/containers/prunerP T)r rS r rA r! )r$ rO r r s r( prune_containers"ContainerApiMixin.prune_containers sL % 5 5g >F9 ii+,||DJJsJ :DAAr+ c p X#US.nU R U R SU5 US9nU R U5 g)a
Remove a container. Similar to the ``docker rm`` command.
Args:
container (str): The container to remove
v (bool): Remove the volumes associated with the container
link (bool): Remove the specified link and not the underlying
container
force (bool): Force the removal of a running container (uses
``SIGKILL``)
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
)vlinkforcez/containers/{0}rP N)_deleter r )r$ r r r r r rX s r( remove_container"ContainerApiMixin.remove_container sB " 7ll II' 3F
s#r+ c p U R SU5 nSU0nU R X4S9nU R U5 g)z
Rename a container. Similar to the ``docker rename`` command.
Args:
container (str): ID of the container to rename
name (str): New name for the container
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
z/containers/{0}/renamerp rP Nr )r$ r rp r r rX s r( renameContainerApiMixin.rename s< ii0)<$ jjj, s#r+ c p X#S.nU R SU5 nU R XTS9nU R U5 g)z
Resize the tty session.
Args:
container (str or dict): The container to resize
height (int): Height of tty session
width (int): Width of tty session
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
)hwz/containers/{0}/resizerP Nr )r$ r heightwidthr r rX s r( resizeContainerApiMixin.resize s; *ii0)<jjj, s#r+ c SU0nU R SU5 nU R nUb XR-
nU R XCUS9nU R U5 g)a
Restart a container. Similar to the ``docker restart`` command.
Args:
container (str or dict): The container to restart. If a dict, the
``Id`` key is used.
timeout (int): Number of seconds to try to stop for before killing
the container. Once killed it will then be restarted. Default
is 10 seconds.
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
tz/containers/{0}/restartNr timeoutr r r! r r$ r r r r conn_timeoutrX s r( restartContainerApiMixin.restart+ sU w ii19=|| # #Ljj\jB s#r+ c U( d U( a [ R " S5 eU R SU5 nU R U5 nU R U5 g)a
Start a container. Similar to the ``docker start`` command, but
doesn't support attach options.
**Deprecation warning:** Passing configuration options in ``start`` is
no longer supported. Users are expected to provide host config options
in the ``host_config`` parameter of
:py:meth:`~ContainerApiMixin.create_container`.
Args:
container (str): The container to start
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
:py:class:`docker.errors.DeprecatedMethod`
If any argument besides ``container`` are provided.
Example:
>>> container = client.api.create_container(
... image='busybox:latest',
... command='/bin/sleep 30')
>>> client.api.start(container=container.get('Id'))
z|Providing configuration in the start() method is no longer supported. Use the host_config param in create_container instead.z/containers/{0}/startN)r DeprecatedMethodr r! r )r$ r r r r rX s r( startContainerApiMixin.startC sO 8 6))
ii/;jjo s#r+ c U R SU5 nSU0nUb@ [ R " U R S5 ( a [ R
" S5 eXFS' U( a< U( a [ R " S5 eU R U R USUS9US 9$ U( a [ R " S
5 eU R U R XVS 9SS 9$ )
a
Stream statistics for a specific container. Similar to the
``docker stats`` command.
Args:
container (str): The container to stream statistics from
decode (bool): If set to true, stream will be decoded into dicts
on the fly. Only applicable if ``stream`` is True.
False by default.
stream (bool): If set to false, only the current stats will be
returned instead of a stream. True by default.
one_shot (bool): If set to true, Only get a single stat instead of
waiting for 2 cycles. Must be used with stream=false. False by
default.
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
z/containers/{0}/statsr r z0one_shot is not supported for API version < 1.41zone-shotz;one_shot is only available in conjunction with stream=FalseT)r r )decodez8decode is only available in conjunction with stream=TruerP r? )
r r r r r r r _stream_helperrT rA )r$ r r r one_shotr r s r( statsContainerApiMixin.statsi s , ii/; f
v66 ++F "*: ,,# && #d6 :6 '
,,N << # =D<I Ir+ c Uc 0 nSnOSU0nU R SU5 nU R nUb XR-
nU R XCUS9nU R U5 g)a
Stops a container. Similar to the ``docker stop`` command.
Args:
container (str): The container to stop
timeout (int): Timeout in seconds to wait for the container to
stop before sending a ``SIGKILL``. If None, then the
StopTimeout value of the container will be used.
Default: None
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
N
r z/containers/{0}/stopr r r s r( stopContainerApiMixin.stop sd ?FG7^Fii. :|| # #Ljj\jB s#r+ c v U R SU5 n0 nUb X$S' U R U R X4S9S5 $ )a,
Display the running processes of a container.
Args:
container (str): The container to inspect
ps_args (str): An optional arguments passed to ps (e.g. ``aux``)
Returns:
(str): The output of the top
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
z/containers/{0}/topps_argsrP T)r rA rT )r$ r r r% r s r( topContainerApiMixin.top sD
II+Y 7 '9 ||DIIaI 7>>r+ c l U R SU5 nU R U5 nU R U5 g)z`
Unpause all processes within a container.
Args:
container (str): The container to unpause
z/containers/{0}/unpauseNr r s r( unpauseContainerApiMixin.unpause s0 ii19=jjo s#r+ z1.22c
~ U R SU5 n
0 nU( a X.S' U( a X>S' U( a X^S' U( a XNS' U( a XnS' U( a X~S' U( a [ R " U5 US' U ( a [ R " U 5 US ' U
( a [ R " U
5 US
' U ( a [ R " U 5 US ' U ( a@ [ R " U R S 5 ( a [
R " S
5 eXS' U R XS9nU R US5 $ )a
Update resource configs of one or more containers.
Args:
container (str): The container to inspect
blkio_weight (int): Block IO (relative weight), between 10 and 1000
cpu_period (int): Limit CPU CFS (Completely Fair Scheduler) period
cpu_quota (int): Limit CPU CFS (Completely Fair Scheduler) quota
cpu_shares (int): CPU shares (relative weight)
cpuset_cpus (str): CPUs in which to allow execution
cpuset_mems (str): MEMs in which to allow execution
mem_limit (float or str): Memory limit
mem_reservation (float or str): Memory soft limit
memswap_limit (int or str): Total memory (memory + swap), -1 to
disable swap
kernel_memory (int or str): Kernel memory limit
restart_policy (dict): Restart policy dictionary
Returns:
(dict): Dictionary containing a ``Warnings`` key.
Raises:
:py:class:`docker.errors.APIError`
If the server returns an error.
z/containers/{0}/update BlkioWeight CpuPeriod CpuSharesCpuQuota
CpusetCpus
CpusetMemsMemoryMemoryReservation
MemorySwap KernelMemoryz1.23z=restart policy update is not supported for API version < 1.23
RestartPolicy)r> T) r r parse_bytesr r r r rB rA )r$ r blkio_weight
cpu_period cpu_quota
cpu_shares cpuset_cpus cpuset_mems mem_limitmem_reservation
memswap_limit
kernel_memoryrestart_policyr r> rX s r( update_container"ContainerApiMixin.update_container s B ii0)< ". * * ( !, !, " . .y 9DN (-(9(9/(JD$ % !&!2!2=!AD #(#4#4]#CD
v66 ++- %3 !ooco-||C&&r+ c U R SU5 n0 nUb@ [ R " U R S5 ( a [ R
" S5 eX5S' U R
XBUS9nU R US5 $ )a
Block until a container stops, then return its exit code. Similar to
the ``docker wait`` command.
Args:
container (str or dict): The container to wait on. If a dict, the
``Id`` key is used.
timeout (int): Request timeout
condition (str): Wait until a container state reaches the given
condition, either ``not-running`` (default), ``next-exit``,
or ``removed``
Returns:
(dict): The API's response as a Python dictionary, including
the container's exit code under the ``StatusCode`` attribute.
Raises:
:py:class:`requests.exceptions.ReadTimeout`
If the timeout is exceeded.
:py:class:`docker.errors.APIError`
If the server returns an error.
z/containers/{0}/waitz1.30z6wait condition is not supported for API version < 1.30 condition)r r T)r r r r r r r! rA )r$ r r r( r r rX s r( waitContainerApiMixin.wait sz 0 ii. :
v66 ++L #,; jjfj=||C&&r+ )TTFFF)NF)NNNNNN) FFFFNNFN)NNNFFFNNNFNNNNNNNNNNNNTN)NNr )TTFFrJ NNN)FFF)r )NTN) NNNNNNNNNNN)(__name__
__module__ __qualname____firstlineno__r check_resourcer) r5 rF rZ r rc rd r r r r r r r r r r r r r minimum_versionr r r r r r r r r r r% r) __static_attributes__r+ r+ r( r r
s
+&48/43 '3j +&*
'*
X +&CG/3!
'!
F FK;@ CJ IMJN37GKHLDH=A489=UIn? ' ^+@14">H +&
'
& +&+B ? '?, +&6M"'2
'2
h +&
'
& +&$ '$, +&?D>BP 'Pd +&
$ '
$ +&/ '/b +&& '&0 6"B #B* +&$ '$, +&$ '$" +&$ '$$ +&$ '$. +&#$ '#$J +&-J '-J^ +&$ '$6 +&? '?* +& $ ' $ 6"
+&GKGK@D >' ' #>'@ +&!' '!'r+ r N)
r r r constantsr typesr r r
r r
r r+ r+ r( r7 s, / % # " $n' n'r+