docker API Reference
Full documentation for docker (7.2.0)
docker.APIClient
Python Library Documentation: class APIClient in module docker.api.client
class APIClient(requests.sessions.Session, docker.api.build.BuildApiMixin, docker.api.config.ConfigApiMixin, docker.api.container.ContainerApiMixin, docker.api.daemon.DaemonApiMixin, docker.api.exec_api.ExecApiMixin, docker.api.image.ImageApiMixin, docker.api.network.NetworkApiMixin, docker.api.plugin.PluginApiMixin, docker.api.secret.SecretApiMixin, docker.api.service.ServiceApiMixin, docker.api.swarm.SwarmApiMixin, docker.api.volume.VolumeApiMixin)
| APIClient(base_url=None, version=None, timeout=60, tls=False, user_agent='docker-sdk-python/7.2.0', num_pools=None, credstore_env=None, use_ssh_client=False, max_pool_size=10)
|
| A low-level client for the Docker Engine API.
|
| Example:
|
| >>> import docker
| >>> client = docker.APIClient(base_url='unix://var/run/docker.sock')
| >>> client.version()
| {u'ApiVersion': u'1.33',
| u'Arch': u'amd64',
| u'BuildTime': u'2017-11-19T18:46:37.000000000+00:00',
| u'GitCommit': u'f4ffd2511c',
| u'GoVersion': u'go1.9.2',
| u'KernelVersion': u'4.14.3-1-ARCH',
| u'MinAPIVersion': u'1.12',
| u'Os': u'linux',
| u'Version': u'17.10.0-ce'}
|
| Args:
| base_url (str): URL to the Docker server. For example,
| ``unix:///var/run/docker.sock`` or ``tcp://127.0.0.1:1234``.
| version (str): The version of the API to use. Set to ``auto`` to
| automatically detect the server's version. Default: ``1.35``
| timeout (int): Default timeout for API calls, in seconds.
| tls (bool or :py:class:`~docker.tls.TLSConfig`): Enable TLS. Pass
| ``True`` to enable it with default options, or pass a
| :py:class:`~docker.tls.TLSConfig` object to use custom
| configuration.
| user_agent (str): Set a custom user agent for requests to the server.
| credstore_env (dict): Override environment variables when calling the
| credential store process.
| use_ssh_client (bool): If set to `True`, an ssh connection is made
| via shelling out to the ssh client. Ensure the ssh client is
| installed and configured on the host.
| max_pool_size (int): The maximum number of connections
| to save in the pool.
|
| Method resolution order:
| APIClient
| requests.sessions.Session
| requests.sessions.SessionRedirectMixin
| docker.api.build.BuildApiMixin
| docker.api.config.ConfigApiMixin
| docker.api.container.ContainerApiMixin
| docker.api.daemon.DaemonApiMixin
| docker.api.exec_api.ExecApiMixin
| docker.api.image.ImageApiMixin
| docker.api.network.NetworkApiMixin
| docker.api.plugin.PluginApiMixin
| docker.api.secret.SecretApiMixin
| docker.api.service.ServiceApiMixin
| docker.api.swarm.SwarmApiMixin
| docker.api.volume.VolumeApiMixin
| builtins.object
|
| Methods defined here:
|
| __init__(self, base_url=None, version=None, timeout=60, tls=False, user_agent='docker-sdk-python/7.2.0', num_pools=None, credstore_env=None, use_ssh_client=False, max_pool_size=10)
| Initialize self. See help(type(self)) for accurate signature.
|
| get_adapter(self, url)
| Returns the appropriate connection adapter for the given URL.
|
| :rtype: requests.adapters.BaseAdapter
|
| reload_config(self, dockercfg_path=None)
| Force a reload of the auth configuration
|
| Args:
| dockercfg_path (str): Use a custom path for the Docker config file
| (default ``$HOME/.docker/config.json`` if present,
| otherwise ``$HOME/.dockercfg``)
|
| Returns:
| None
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| api_version
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| __attrs__ = ['headers', 'cookies', 'auth', 'proxies', 'hooks', 'params...
|
| ----------------------------------------------------------------------
| Methods inherited from requests.sessions.Session:
|
| __enter__(self) -> 'Self'
|
| __exit__(self, *args: 'Any') -> 'None'
|
| __getstate__(self) -> 'dict[str, Any]'
| Helper for pickle.
|
| __setstate__(self, state: 'dict[str, Any]') -> 'None'
|
| close(self) -> 'None'
| Closes all adapters and as such the session
|
| delete(self, url: '_t.UriType', **kwargs: 'Unpack[_t.RequestKwargs]') -> 'Response'
| Sends a DELETE request. Returns :class:`Response` object.
|
| :param url: URL for the new :class:`Request` object.
| :param \*\*kwargs: Optional arguments that ``request`` takes.
| :rtype: requests.Response
|
| get(self, url: '_t.UriType', params: '_t.ParamsType' = None, **kwargs: 'Unpack[_t.GetKwargs]') -> 'Response'
| Sends a GET request. Returns :class:`Response` object.
|
| :param url: URL for the new :class:`Request` object.
| :param params: (optional) Dictionary, list of tuples or bytes to send
| in the query string for the :class:`Request`.
| :param \*\*kwargs: Optional arguments that ``request`` takes.
| :rtype: requests.Response
|
| head(self, url: '_t.UriType', **kwargs: 'Unpack[_t.RequestKwargs]') -> 'Response'
| Sends a HEAD request. Returns :class:`Response` object.
|
| :param url: URL for the new :class:`Request` object.
| :param \*\*kwargs: Optional arguments that ``request`` takes.
| :rtype: requests.Response
|
| merge_environment_settings(self, url: 'str', proxies: 'dict[str, str] | None', stream: 'bool | None', verify: '_t.VerifyType | None', cert: '_t.CertType') -> 'dict[str, Any]'
| Check the environment and merge it with some settings.
|
| :rtype: dict
|
| mount(self, prefix: 'str', adapter: 'BaseAdapter') -> 'None'
| Registers a connection adapter to a prefix.
|
| Adapters are sorted in descending order by prefix length.
|
| options(self, url: '_t.UriType', **kwargs: 'Unpack[_t.RequestKwargs]') -> 'Response'
| Sends a OPTIONS request. Returns :class:`Response` object.
|
| :param url: URL for the new :class:`Request` object.
| :param \*\*kwargs: Optional arguments that ``request`` takes.
| :rtype: requests.Response
|
| patch(self, url: '_t.UriType', data: '_t.DataType' = None, **kwargs: 'Unpack[_t.DataKwargs]') -> 'Response'
| Sends a PATCH request. Returns :class:`Response` object.
|
| :param url: URL for the new :class:`Request` object.
| :param data: (optional) Dictionary, list of tuples, bytes, or file-like
| object to send in the body of the :class:`Request`.
| :param \*\*kwargs: Optional arguments that ``request`` takes.
| :rtype: requests.Response
|
| post(self, url: '_t.UriType', data: '_t.DataType' = None, json: '_t.JsonType' = None, **kwargs: 'Unpack[_t.PostKwargs]') -> 'Response'
| Sends a POST request. Returns :class:`Response` object.
|
| :param url: URL for the new :class:`Request` object.
| :param data: (optional) Dictionary, list of tuples, bytes, or file-like
| object to send in the body of the :class:`Request`.
| :param json: (optional) json to send in the body of the :class:`Request`.
| :param \*\*kwargs: Optional arguments that ``request`` takes.
| :rtype: requests.Response
|
| prepare_request(self, request: 'Request') -> 'PreparedRequest'
| Constructs a :class:`PreparedRequest <PreparedRequest>` for
| transmission and returns it. The :class:`PreparedRequest` has settings
| merged from the :class:`Request <Request>` instance and those of the
| :class:`Session`.
|
| :param request: :class:`Request` instance to prepare with this
| session's settings.
| :rtype: requests.PreparedRequest
|
| put(self, url: '_t.UriType', data: '_t.DataType' = None, **kwargs: 'Unpack[_t.DataKwargs]') -> 'Response'
| Sends a PUT request. Returns :class:`Response` object.
|
| :param url: URL for the new :class:`Request` object.
| :param data: (optional) Dictionary, list of tuples, bytes, or file-like
| object to send in the body of the :class:`Request`.
| :param \*\*kwargs: Optional arguments that ``request`` takes.
| :rtype: requests.Response
|
| request(self, method: 'str', url: '_t.UriType', params: '_t.ParamsType' = None, data: '_t.DataType' = None, headers: '_t.HeadersType' = None, cookies: 'RequestsCookieJar | CookieJar | dict[str, str] | None' = None, files: '_t.FilesType' = None, auth: '_t.AuthType' = None, timeout: '_t.TimeoutType' = None, allow_redirects: 'bool' = True, proxies: 'dict[str, str] | None' = None, hooks: '_t.HooksInputType | None' = None, stream: 'bool | None' = None, verify: '_t.VerifyType | None' = None, cert: '_t.CertType' = None, json: '_t.JsonType' = None) -> 'Response'
| Constructs a :class:`Request <Request>`, prepares it and sends it.
| Returns :class:`Response <Response>` object.
|
| :param method: method for the new :class:`Request` object.
| :param url: URL for the new :class:`Request` object.
| :param params: (optional) Dictionary or bytes to be sent in the query
| string for the :class:`Request`.
| :param data: (optional) Dictionary, list of tuples, bytes, or file-like
| object to send in the body of the :class:`Request`.
| :param json: (optional) json to send in the body of the
| :class:`Request`.
| :param headers: (optional) Dictionary of HTTP Headers to send with the
| :class:`Request`.
| :param cookies: (optional) Dict or CookieJar object to send with the
| :class:`Request`.
| :param files: (optional) Dictionary of ``'filename': file-like-objects``
| for multipart encoding upload.
| :param auth: (optional) Auth tuple or callable to enable
| Basic/Digest/Custom HTTP Auth.
| :param timeout: (optional) How many seconds to wait for the server to send
| data before giving up, as a float, or a :ref:`(connect timeout,
| read timeout) <timeouts>` tuple.
| :type timeout: float or tuple
| :param allow_redirects: (optional) Set to True by default.
| :type allow_redirects: bool
| :param proxies: (optional) Dictionary mapping protocol or protocol and
| hostname to the URL of the proxy.
| :param hooks: (optional) Dictionary mapping hook name to one event or
| list of events, event must be callable.
| :param stream: (optional) whether to immediately download the response
| content. Defaults to ``False``.
| :param verify: (optional) Either a boolean, in which case it controls whether we verify
| the server's TLS certificate, or a string, in which case it must be a path
| to a CA bundle to use. Defaults to ``True``. When set to
| ``False``, requests will accept any TLS certificate presented by
| the server, and will ignore hostname mismatches and/or expired
| certificates, which will make your application vulnerable to
| man-in-the-middle (MitM) attacks. Setting verify to ``False``
| may be useful during local development or testing.
| :param cert: (optional) if String, path to ssl client cert file (.pem).
| If Tuple, ('cert', 'key') pair.
| :rtype: requests.Response
|
| send(self, request: 'PreparedRequest', **kwargs: 'Any') -> 'Response'
| Send a given PreparedRequest.
|
| :rtype: requests.Response
|
| ----------------------------------------------------------------------
| Methods inherited from requests.sessions.SessionRedirectMixin:
|
| get_redirect_target(self, resp: 'Response') -> 'str | None'
| Receives a Response. Returns a redirect URI or ``None``
|
| rebuild_auth(self, prepared_request: 'PreparedRequest', response: 'Response') -> 'None'
| When being redirected we may want to strip authentication from the
| request to avoid leaking credentials. This method intelligently removes
| and reapplies authentication where possible to avoid credential loss.
|
| rebuild_method(self, prepared_request: 'PreparedRequest', response: 'Response') -> 'None'
| When being redirected we may want to change the method of the request
| based on certain specs or browser behavior.
|
| rebuild_proxies(self, prepared_request: 'PreparedRequest', proxies: 'dict[str, str] | None') -> 'dict[str, str]'
| This method re-evaluates the proxy configuration by considering the
| environment variables. If we are redirected to a URL covered by
| NO_PROXY, we strip the proxy configuration. Otherwise, we set missing
| proxy keys for this URL (in case they were stripped by a previous
| redirect).
|
| This method also replaces the Proxy-Authorization header where
| necessary.
|
| :rtype: dict
|
| resolve_redirects(self, resp: 'Response', req: 'PreparedRequest', stream: 'bool' = False, timeout: '_t.TimeoutType' = None, verify: '_t.VerifyType' = True, cert: '_t.CertType' = None, proxies: 'dict[str, str] | None' = None, yield_requests: 'bool' = False, **adapter_kwargs: 'Any') -> 'Generator[Response, None, None]'
| Receives a Response. Returns a generator of Responses or Requests.
|
| should_strip_auth(self, old_url: 'str', new_url: 'str') -> 'bool'
| Decide whether Authorization header should be removed when redirecting
|
| ----------------------------------------------------------------------
| Data descriptors inherited from requests.sessions.SessionRedirectMixin:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from docker.api.build.BuildApiMixin:
|
| build(self, path=None, tag=None, quiet=False, fileobj=None, nocache=False, rm=False, timeout=None, custom_context=False, encoding=None, pull=False, forcerm=False, dockerfile=None, container_limits=None, decode=False, buildargs=None, gzip=False, shmsize=None, labels=None, cache_from=None, target=None, network_mode=None, squash=None, extra_hosts=None, platform=None, isolation=None, use_config_proxy=True)
| Similar to the ``docker build`` command. Either ``path`` or ``fileobj``
| needs to be set. ``path`` can be a local path (to a directory
| containing a Dockerfile) or a remote URL. ``fileobj`` must be a
| readable file-like object to a Dockerfile.
|
| If you have a tar file for the Docker build context (including a
| Dockerfile) already, pass a readable file-like object to ``fileobj``
| and also pass ``custom_context=True``. If the stream is compressed
| also, set ``encoding`` to the correct value (e.g ``gzip``).
|
| Example:
| >>> from io import BytesIO
| >>> from docker import APIClient
| >>> dockerfile = '''
| ... # Shared Volume
| ... FROM busybox:buildroot-2014.02
| ... VOLUME /data
| ... CMD ["/bin/sh"]
| ... '''
| >>> f = BytesIO(dockerfile.encode('utf-8'))
| >>> cli = APIClient(base_url='tcp://127.0.0.1:2375')
| >>> response = [line for line in cli.build(
| ... fileobj=f, rm=True, tag='yourname/volume'
| ... )]
| >>> response
| ['{"stream":" ---\u003e a9eb17255234\n"}',
| '{"stream":"Step 1 : VOLUME /data\n"}',
| '{"stream":" ---\u003e Running in abdc1e6896c6\n"}',
| '{"stream":" ---\u003e 713bca62012e\n"}',
| '{"stream":"Removing intermediate container abdc1e6896c6\n"}',
| '{"stream":"Step 2 : CMD [\"/bin/sh\"]\n"}',
| '{"stream":" ---\u003e Running in dba30f2a1a7e\n"}',
| '{"stream":" ---\u003e 032b8b2855fc\n"}',
| '{"stream":"Removing intermediate container dba30f2a1a7e\n"}',
| '{"stream":"Successfully built 032b8b2855fc\n"}']
|
| Args:
| path (str): Path to the directory containing the Dockerfile
| fileobj: A file object to use as the Dockerfile. (Or a file-like
| object)
| tag (str): A tag to add to the final image
| quiet (bool): Whether to return the status
| nocache (bool): Don't use the cache when set to ``True``
| rm (bool): Remove intermediate containers. The ``docker build``
| command now defaults to ``--rm=true``, but we have kept the old
| default of `False` to preserve backward compatibility
| timeout (int): HTTP timeout
| custom_context (bool): Optional if using ``fileobj``
| encoding (str): The encoding for a stream. Set to ``gzip`` for
| compressing
| pull (bool): Downloads any updates to the FROM image in Dockerfiles
| forcerm (bool): Always remove intermediate containers, even after
| unsuccessful builds
| dockerfile (str): path within the build context to the Dockerfile
| gzip (bool): If set to ``True``, gzip compression/encoding is used
| buildargs (dict): A dictionary of build arguments
| container_limits (dict): A dictionary of limits applied to each
| container created by the build process. Valid keys:
|
| - memory (int): set memory limit for build
| - memswap (int): Total memory (memory + swap), -1 to disable
| swap
| - cpushares (int): CPU shares (relative weight)
| - cpusetcpus (str): CPUs in which to allow execution, e.g.,
| ``"0-3"``, ``"0,1"``
| decode (bool): If set to ``True``, the returned stream will be
| decoded into dicts on the fly. Default ``False``
| shmsize (int): Size of `/dev/shm` in bytes. The size must be
| greater than 0. If omitted the system uses 64MB
| labels (dict): A dictionary of labels to set on the image
| cache_from (:py:class:`list`): A list of images used for build
| cache resolution
| target (str): Name of the build-stage to build in a multi-stage
| Dockerfile
| network_mode (str): networking mode for the run commands during
| build
| squash (bool): Squash the resulting images layers into a
| single layer.
| extra_hosts (dict): Extra hosts to add to /etc/hosts in building
| containers, as a mapping of hostname to IP address.
| platform (str): Platform in the format ``os[/arch[/variant]]``
| isolation (str): Isolation technology used during build.
| Default: `None`.
| 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 built.
|
| Returns:
| A generator for the build output.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
| ``TypeError``
| If neither ``path`` nor ``fileobj`` is specified.
|
| prune_builds(self, filters=None, keep_storage=None, all=None)
| Delete the builder cache
|
| Args:
| filters (dict): Filters to process on the prune list.
| Needs Docker API v1.39+
| Available filters:
| - dangling (bool): When set to true (or 1), prune only
| unused and untagged images.
| - until (str): Can be Unix timestamps, date formatted
| timestamps, or Go duration strings (e.g. 10m, 1h30m) computed
| relative to the daemon's local time.
| keep_storage (int): Amount of disk space in bytes to keep for cache.
| Needs Docker API v1.39+
| all (bool): Remove all types of build cache.
| Needs Docker API v1.39+
|
| Returns:
| (dict): A dictionary containing information about the operation's
| result. The ``SpaceReclaimed`` key indicates the amount of
| bytes of disk space reclaimed.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| ----------------------------------------------------------------------
| Methods inherited from docker.api.config.ConfigApiMixin:
|
| configs(self, filters=None)
| List configs
|
| Args:
| filters (dict): A map of filters to process on the configs
| list. Available filters: ``names``
|
| Returns (list): A list of configs
|
| create_config(self, name, data, labels=None, templating=None)
| Create a config
|
| Args:
| name (string): Name of the config
| data (bytes): Config data to be stored
| labels (dict): A mapping of labels to assign to the config
| templating (dict): dictionary containing the name of the
| templating driver to be used expressed as
| { name: <templating_driver_name>}
|
| Returns (dict): ID of the newly created config
|
| inspect_config(self, id)
| Retrieve config metadata
|
| Args:
| id (string): Full ID of the config to inspect
|
| Returns (dict): A dictionary of metadata
|
| Raises:
| :py:class:`docker.errors.NotFound`
| if no config with that ID exists
|
| remove_config(self, id)
| Remove a config
|
| Args:
| id (string): Full ID of the config to remove
|
| Returns (boolean): True if successful
|
| Raises:
| :py:class:`docker.errors.NotFound`
| if no config with that ID exists
|
| ----------------------------------------------------------------------
| Methods inherited from docker.api.container.ContainerApiMixin:
|
| attach(self, container, stdout=True, stderr=True, stream=False, logs=False, demux=False)
| 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.
|
| attach_socket(self, container, params=None, ws=False)
| 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.
|
| commit(self, container, repository=None, tag=None, message=None, author=None, pause=True, changes=None, conf=None)
| 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
| pause (bool): Whether to pause the container before committing
| changes (str): Dockerfile instructions to apply while committing
| conf (dict): The configuration for the container. See the
| `Engine API documentation
| <https://docs.docker.com/reference/api/docker_remote_api/>`_
| for full details.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| containers(self, quiet=False, all=False, trunc=False, latest=False, since=None, before=None, limit=-1, size=False, filters=None)
| 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
| ``<image-name>[:tag]``, ``<image-id>``, or
| ``<image@digest>``.
| - `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
| <https://docs.docker.com/engine/reference/commandline/ps>`_.
|
| Returns:
| A list of dicts, one per container
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| create_container(self, image, command=None, hostname=None, user=None, detach=False, stdin_open=False, tty=False, ports=None, environment=None, volumes=None, network_disabled=False, name=None, entrypoint=None, working_dir=None, domainname=None, host_config=None, mac_address=None, labels=None, stop_signal=None, networking_config=None, healthcheck=None, stop_timeout=None, runtime=None, use_config_proxy=True, platform=None)
| 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',
| },
| '/autofs/user1': {
| 'bind': '/mnt/vol3',
| 'mode': 'rw',
| 'propagation': 'shared'
| }
| })
| )
|
| 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', '/mnt/vol3'],
| host_config=client.api.create_host_config(binds=[
| '/home/user1/:/mnt/vol2',
| '/var/www:/mnt/vol1:ro',
| '/autofs/user1:/mnt/vol3:rw,shared',
| ])
| )
|
| **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.
|
| create_container_config(self, *args, **kwargs)
|
| create_container_from_config(self, config, name=None, platform=None)
|
| create_endpoint_config(self, *args, **kwargs)
| 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'
| )
|
| create_host_config(self, *args, **kwargs)
| 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
| ``<path_on_host>:<path_in_container>:<cgroup_permissions>``.
|
| 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:<name|id>`` 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}
|
| create_networking_config(self, *args, **kwargs)
| 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
| )
|
| diff(self, container)
| 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.
|
| export(self, container, chunk_size=2097152)
| 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.
|
| get_archive(self, container, path, chunk_size=2097152, encode_stream=False)
| 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()
|
| inspect_container(self, container)
| 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.
|
| kill(self, container, signal=None)
| 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.
|
| logs(self, container, stdout=True, stderr=True, stream=False, timestamps=False, tail='all', since=None, follow=None, until=None)
| 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 of bytes or bytes)
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| pause(self, container)
| 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.
|
| port(self, container, private_port)
| 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'}]
|
| prune_containers(self, filters=None)
| 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.
|
| put_archive(self, container, path, data)
| Insert a file or folder in an existing container using a tar archive as
| source.
|
| Args:
| container (str): The container where the file(s) will be extracted
| path (str): Path inside the container where the file(s) will be
| extracted. Must exist.
| data (bytes or stream): tar data to be extracted
|
| Returns:
| (bool): True if the call succeeds.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| remove_container(self, container, v=False, link=False, force=False)
| 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.
|
| rename(self, container, name)
| 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.
|
| resize(self, container, height, width)
| 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.
|
| restart(self, container, timeout=10)
| 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.
|
| start(self, container, *args, **kwargs)
| 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'))
|
| stats(self, container, decode=None, stream=True, one_shot=None)
| 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.
|
| stop(self, container, timeout=None)
| 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.
|
| top(self, container, ps_args=None)
| 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.
|
| unpause(self, container)
| Unpause all processes within a container.
|
| Args:
| container (str): The container to unpause
|
| update_container(self, container, blkio_weight=None, cpu_period=None, cpu_quota=None, cpu_shares=None, cpuset_cpus=None, cpuset_mems=None, mem_limit=None, mem_reservation=None, memswap_limit=None, kernel_memory=None, restart_policy=None)
| 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.
|
| wait(self, container, timeout=None, condition=None)
| 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.
|
| ----------------------------------------------------------------------
| Methods inherited from docker.api.daemon.DaemonApiMixin:
|
| df(self)
| Get data usage information.
|
| Returns:
| (dict): A dictionary representing different resource categories
| and their respective data usage.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| events(self, since=None, until=None, filters=None, decode=None)
| Get real-time events from the server. Similar to the ``docker events``
| command.
|
| Args:
| since (UTC datetime or int): Get events from this point
| until (UTC datetime or int): Get events until this point
| filters (dict): Filter the events by event time, container or image
| decode (bool): If set to true, stream will be decoded into dicts on
| the fly. False by default.
|
| Returns:
| A :py:class:`docker.types.daemon.CancellableStream` generator
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| Example:
|
| >>> for event in client.events(decode=True)
| ... print(event)
| {u'from': u'image/with:tag',
| u'id': u'container-id',
| u'status': u'start',
| u'time': 1423339459}
| ...
|
| or
|
| >>> events = client.events()
| >>> for event in events:
| ... print(event)
| >>> # and cancel from another thread
| >>> events.close()
|
| info(self)
| Display system-wide information. Identical to the ``docker info``
| command.
|
| Returns:
| (dict): The info as a dict
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| login(self, username, password=None, email=None, registry=None, reauth=False, dockercfg_path=None)
| Authenticate with a registry. Similar to the ``docker login`` command.
|
| Args:
| username (str): The registry username
| password (str): The plaintext password
| email (str): The email for the registry account
| registry (str): URL to the registry. E.g.
| ``https://index.docker.io/v1/``
| reauth (bool): Whether or not to refresh existing authentication on
| the Docker server.
| dockercfg_path (str): Use a custom path for the Docker config file
| (default ``$HOME/.docker/config.json`` if present,
| otherwise ``$HOME/.dockercfg``)
|
| Returns:
| (dict): The response from the login request
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| ping(self)
| Checks the server is responsive. An exception will be raised if it
| isn't responding.
|
| Returns:
| (bool) The response from the server.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| version(self, api_version=True)
| Returns version information from the server. Similar to the ``docker
| version`` command.
|
| Returns:
| (dict): The server version information
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| ----------------------------------------------------------------------
| Methods inherited from docker.api.exec_api.ExecApiMixin:
|
| exec_create(self, container, cmd, stdout=True, stderr=True, stdin=False, tty=False, privileged=False, user='', environment=None, workdir=None, detach_keys=None)
| Sets up an exec instance in a running container.
|
| Args:
| container (str): Target container where exec instance will be
| created
| cmd (str or list): Command to be executed
| stdout (bool): Attach to stdout. Default: ``True``
| stderr (bool): Attach to stderr. Default: ``True``
| stdin (bool): Attach to stdin. Default: ``False``
| tty (bool): Allocate a pseudo-TTY. Default: False
| privileged (bool): Run as privileged.
| user (str): User to execute command as. Default: root
| environment (dict or list): A dictionary or a list of strings in
| the following format ``["PASSWORD=xxx"]`` or
| ``{"PASSWORD": "xxx"}``.
| workdir (str): Path to working directory for this exec session
| detach_keys (str): Override the key sequence for detaching
| a container. Format is a single character `[a-Z]`
| or `ctrl-<value>` where `<value>` is one of:
| `a-z`, `@`, `^`, `[`, `,` or `_`.
| ~/.docker/config.json is used by default.
|
| Returns:
| (dict): A dictionary with an exec ``Id`` key.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| exec_inspect(self, exec_id)
| Return low-level information about an exec command.
|
| Args:
| exec_id (str): ID of the exec instance
|
| Returns:
| (dict): Dictionary of values returned by the endpoint.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| exec_resize(self, exec_id, height=None, width=None)
| Resize the tty session used by the specified exec command.
|
| Args:
| exec_id (str): ID of the exec instance
| height (int): Height of tty session
| width (int): Width of tty session
|
| exec_start(self, exec_id, detach=False, tty=False, stream=False, socket=False, demux=False)
| Start a previously set up exec instance.
|
| Args:
| exec_id (str): ID of the exec instance
| detach (bool): If true, detach from the exec command.
| Default: False
| tty (bool): Allocate a pseudo-TTY. Default: False
| stream (bool): Return response data progressively as an iterator
| of strings, rather than a single string.
| socket (bool): Return the connection socket to allow custom
| read/write operations. Must be closed by the caller when done.
| demux (bool): Return stdout and stderr separately
|
| Returns:
|
| (generator or str or tuple): If ``stream=True``, a generator
| yielding response chunks. If ``socket=True``, a socket object for
| the connection. A string containing response data otherwise. If
| ``demux=True``, a tuple with two elements of type byte: stdout and
| stderr.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| ----------------------------------------------------------------------
| Methods inherited from docker.api.image.ImageApiMixin:
|
| get_image(self, image, chunk_size=2097152)
| Get a tarball of an image. Similar to the ``docker save`` command.
|
| Args:
| image (str): Image name to get
| 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): A stream of raw archive data.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| Example:
|
| >>> image = client.api.get_image("busybox:latest")
| >>> f = open('/tmp/busybox-latest.tar', 'wb')
| >>> for chunk in image:
| >>> f.write(chunk)
| >>> f.close()
|
| history(self, image)
| Show the history of an image.
|
| Args:
| image (str): The image to show history for
|
| Returns:
| (list): The history of the image
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| images(self, name=None, quiet=False, all=False, filters=None)
| List images. Similar to the ``docker images`` command.
|
| Args:
| name (str): Only show images belonging to the repository ``name``
| quiet (bool): Only return numeric IDs as a list.
| all (bool): Show intermediate image layers. By default, these are
| filtered out.
| filters (dict): Filters to be processed on the image list.
| Available filters:
| - ``dangling`` (bool)
| - `label` (str|list): format either ``"key"``, ``"key=value"``
| or a list of such.
|
| Returns:
| (dict or list): A list if ``quiet=True``, otherwise a dict.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| import_image(self, src=None, repository=None, tag=None, image=None, changes=None, stream_src=False)
| Import an image. Similar to the ``docker import`` command.
|
| If ``src`` is a string or unicode string, it will first be treated as a
| path to a tarball on the local system. If there is an error reading
| from that file, ``src`` will be treated as a URL instead to fetch the
| image from. You can also pass an open file handle as ``src``, in which
| case the data will be read from that file.
|
| If ``src`` is unset but ``image`` is set, the ``image`` parameter will
| be taken as the name of an existing image to import from.
|
| Args:
| src (str or file): Path to tarfile, URL, or file-like object
| repository (str): The repository to create
| tag (str): The tag to apply
| image (str): Use another image like the ``FROM`` Dockerfile
| parameter
|
| import_image_from_data(self, data, repository=None, tag=None, changes=None)
| Like :py:meth:`~docker.api.image.ImageApiMixin.import_image`, but
| allows importing in-memory bytes data.
|
| Args:
| data (bytes collection): Bytes collection containing valid tar data
| repository (str): The repository to create
| tag (str): The tag to apply
|
| import_image_from_file(self, filename, repository=None, tag=None, changes=None)
| Like :py:meth:`~docker.api.image.ImageApiMixin.import_image`, but only
| supports importing from a tar file on disk.
|
| Args:
| filename (str): Full path to a tar file.
| repository (str): The repository to create
| tag (str): The tag to apply
|
| Raises:
| IOError: File does not exist.
|
| import_image_from_image(self, image, repository=None, tag=None, changes=None)
| Like :py:meth:`~docker.api.image.ImageApiMixin.import_image`, but only
| supports importing from another image, like the ``FROM`` Dockerfile
| parameter.
|
| Args:
| image (str): Image name to import from
| repository (str): The repository to create
| tag (str): The tag to apply
|
| import_image_from_stream(self, stream, repository=None, tag=None, changes=None)
|
| import_image_from_url(self, url, repository=None, tag=None, changes=None)
| Like :py:meth:`~docker.api.image.ImageApiMixin.import_image`, but only
| supports importing from a URL.
|
| Args:
| url (str): A URL pointing to a tar file.
| repository (str): The repository to create
| tag (str): The tag to apply
|
| inspect_distribution(self, image, auth_config=None)
| Get image digest and platform information by contacting the registry.
|
| Args:
| image (str): The image name to inspect
| auth_config (dict): Override the credentials that are found in the
| config for this request. ``auth_config`` should contain the
| ``username`` and ``password`` keys to be valid.
|
| Returns:
| (dict): A dict containing distribution data
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| inspect_image(self, image)
| Get detailed information about an image. Similar to the ``docker
| inspect`` command, but only for images.
|
| Args:
| image (str): The image 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.
|
| load_image(self, data, quiet=None)
| Load an image that was previously saved using
| :py:meth:`~docker.api.image.ImageApiMixin.get_image` (or ``docker
| save``). Similar to ``docker load``.
|
| Args:
| data (binary): Image data to be loaded.
| quiet (boolean): Suppress progress details in response.
|
| Returns:
| (generator): Progress output as JSON objects. Only available for
| API version >= 1.23
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| prune_images(self, filters=None)
| Delete unused images
|
| Args:
| filters (dict): Filters to process on the prune list.
| Available filters:
| - dangling (bool): When set to true (or 1), prune only
| unused and untagged images.
|
| Returns:
| (dict): A dict containing a list of deleted image IDs and
| the amount of disk space reclaimed in bytes.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| pull(self, repository, tag=None, stream=False, auth_config=None, decode=False, platform=None, all_tags=False)
| Pulls an image. Similar to the ``docker pull`` command.
|
| Args:
| repository (str): The repository to pull
| tag (str): The tag to pull. If ``tag`` is ``None`` or empty, it
| is set to ``latest``.
| stream (bool): Stream the output as a generator. Make sure to
| consume the generator, otherwise pull might get cancelled.
| auth_config (dict): Override the credentials that are found in the
| config for this request. ``auth_config`` should contain the
| ``username`` and ``password`` keys to be valid.
| decode (bool): Decode the JSON data from the server into dicts.
| Only applies with ``stream=True``
| platform (str): Platform in the format ``os[/arch[/variant]]``
| all_tags (bool): Pull all image tags, the ``tag`` parameter is
| ignored.
|
| Returns:
| (generator or str): The output
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| Example:
|
| >>> resp = client.api.pull('busybox', stream=True, decode=True)
| ... for line in resp:
| ... print(json.dumps(line, indent=4))
| {
| "status": "Pulling image (latest) from busybox",
| "progressDetail": {},
| "id": "e72ac664f4f0"
| }
| {
| "status": "Pulling image (latest) from busybox, endpoint: ...",
| "progressDetail": {},
| "id": "e72ac664f4f0"
| }
|
| push(self, repository, tag=None, stream=False, auth_config=None, decode=False)
| Push an image or a repository to the registry. Similar to the ``docker
| push`` command.
|
| Args:
| repository (str): The repository to push to
| tag (str): An optional tag to push
| stream (bool): Stream the output as a blocking generator
| auth_config (dict): Override the credentials that are found in the
| config for this request. ``auth_config`` should contain the
| ``username`` and ``password`` keys to be valid.
| decode (bool): Decode the JSON data from the server into dicts.
| Only applies with ``stream=True``
|
| Returns:
| (generator or str): The output from the server.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| Example:
| >>> resp = client.api.push(
| ... 'yourname/app',
| ... stream=True,
| ... decode=True,
| ... )
| ... for line in resp:
| ... print(line)
| {'status': 'Pushing repository yourname/app (1 tags)'}
| {'status': 'Pushing','progressDetail': {}, 'id': '511136ea3c5a'}
| {'status': 'Image already pushed, skipping', 'progressDetail':{},
| 'id': '511136ea3c5a'}
| ...
|
| remove_image(self, image, force=False, noprune=False)
| Remove an image. Similar to the ``docker rmi`` command.
|
| Args:
| image (str): The image to remove
| force (bool): Force removal of the image
| noprune (bool): Do not delete untagged parents
|
| search(self, term, limit=None)
| Search for images on Docker Hub. Similar to the ``docker search``
| command.
|
| Args:
| term (str): A term to search for.
| limit (int): The maximum number of results to return.
|
| Returns:
| (list of dicts): The response of the search.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| tag(self, image, repository, tag=None, force=False)
| Tag an image into a repository. Similar to the ``docker tag`` command.
|
| Args:
| image (str): The image to tag
| repository (str): The repository to set for the tag
| tag (str): The tag name
| force (bool): Force
|
| Returns:
| (bool): ``True`` if successful
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| Example:
|
| >>> client.api.tag('ubuntu', 'localhost:5000/ubuntu', 'latest',
| force=True)
|
| ----------------------------------------------------------------------
| Methods inherited from docker.api.network.NetworkApiMixin:
|
| connect_container_to_network(self, container, net_id, ipv4_address=None, ipv6_address=None, aliases=None, links=None, link_local_ips=None, driver_opt=None, mac_address=None)
| Connect a container to a network.
|
| Args:
| container (str): container-id/name to be connected to the network
| net_id (str): network id
| 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 (:py:class:`list`): A list of links for this endpoint.
| Containers declared in this list will be linked to this
| container. 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.
| mac_address (str): The MAC address of this container on the
| network. Defaults to ``None``.
|
| create_network(self, name, driver=None, options=None, ipam=None, check_duplicate=None, internal=False, labels=None, enable_ipv6=False, attachable=None, scope=None, ingress=None)
| Create a network. Similar to the ``docker network create``.
|
| Args:
| name (str): Name of the network
| driver (str): Name of the driver used to create the network
| options (dict): Driver options as a key-value dictionary
| ipam (IPAMConfig): Optional custom IP scheme for the network.
| check_duplicate (bool): Request daemon to check for networks with
| same name. Default: ``None``.
| internal (bool): Restrict external access to the network. Default
| ``False``.
| labels (dict): Map of labels to set on the network. Default
| ``None``.
| enable_ipv6 (bool): Enable IPv6 on the network. Default ``False``.
| attachable (bool): If enabled, and the network is in the global
| scope, non-service containers on worker nodes will be able to
| connect to the network.
| scope (str): Specify the network's scope (``local``, ``global`` or
| ``swarm``)
| ingress (bool): If set, create an ingress network which provides
| the routing-mesh in swarm mode.
|
| Returns:
| (dict): The created network reference object
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| Example:
| A network using the bridge driver:
|
| >>> client.api.create_network("network1", driver="bridge")
|
| You can also create more advanced networks with custom IPAM
| configurations. For example, setting the subnet to
| ``192.168.52.0/24`` and gateway address to ``192.168.52.254``.
|
| .. code-block:: python
|
| >>> ipam_pool = docker.types.IPAMPool(
| subnet='192.168.52.0/24',
| gateway='192.168.52.254'
| )
| >>> ipam_config = docker.types.IPAMConfig(
| pool_configs=[ipam_pool]
| )
| >>> client.api.create_network("network1", driver="bridge",
| ipam=ipam_config)
|
| disconnect_container_from_network(self, container, net_id, force=False)
| Disconnect a container from a network.
|
| Args:
| container (str): container ID or name to be disconnected from the
| network
| net_id (str): network ID
| force (bool): Force the container to disconnect from a network.
| Default: ``False``
|
| inspect_network(self, net_id, verbose=None, scope=None)
| Get detailed information about a network.
|
| Args:
| net_id (str): ID of network
| verbose (bool): Show the service details across the cluster in
| swarm mode.
| scope (str): Filter the network by scope (``swarm``, ``global``
| or ``local``).
|
| networks(self, names=None, ids=None, filters=None)
| List networks. Similar to the ``docker network ls`` command.
|
| Args:
| names (:py:class:`list`): List of names to filter by
| ids (:py:class:`list`): List of ids to filter by
| filters (dict): Filters to be processed on the network list.
| Available filters:
| - ``driver=[<driver-name>]`` Matches a network's driver.
| - ``label=[<key>]``, ``label=[<key>=<value>]`` or a list of
| such.
| - ``type=["custom"|"builtin"]`` Filters networks by type.
|
| Returns:
| (dict): List of network objects.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| prune_networks(self, filters=None)
| Delete unused networks
|
| Args:
| filters (dict): Filters to process on the prune list.
|
| Returns:
| (dict): A dict containing a list of deleted network names and
| the amount of disk space reclaimed in bytes.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| remove_network(self, net_id)
| Remove a network. Similar to the ``docker network rm`` command.
|
| Args:
| net_id (str): The network's id
|
| ----------------------------------------------------------------------
| Methods inherited from docker.api.plugin.PluginApiMixin:
|
| configure_plugin(self, name, options)
| Configure a plugin.
|
| Args:
| name (string): The name of the plugin. The ``:latest`` tag is
| optional, and is the default if omitted.
| options (dict): A key-value mapping of options
|
| Returns:
| ``True`` if successful
|
| create_plugin(self, name, plugin_data_dir, gzip=False)
| Create a new plugin.
|
| Args:
| name (string): The name of the plugin. The ``:latest`` tag is
| optional, and is the default if omitted.
| plugin_data_dir (string): Path to the plugin data directory.
| Plugin data directory must contain the ``config.json``
| manifest file and the ``rootfs`` directory.
| gzip (bool): Compress the context using gzip. Default: False
|
| Returns:
| ``True`` if successful
|
| disable_plugin(self, name, force=False)
| Disable an installed plugin.
|
| Args:
| name (string): The name of the plugin. The ``:latest`` tag is
| optional, and is the default if omitted.
| force (bool): To enable the force query parameter.
|
| Returns:
| ``True`` if successful
|
| enable_plugin(self, name, timeout=0)
| Enable an installed plugin.
|
| Args:
| name (string): The name of the plugin. The ``:latest`` tag is
| optional, and is the default if omitted.
| timeout (int): Operation timeout (in seconds). Default: 0
|
| Returns:
| ``True`` if successful
|
| inspect_plugin(self, name)
| Retrieve plugin metadata.
|
| Args:
| name (string): The name of the plugin. The ``:latest`` tag is
| optional, and is the default if omitted.
|
| Returns:
| A dict containing plugin info
|
| plugin_privileges(self, name)
| Retrieve list of privileges to be granted to a plugin.
|
| Args:
| name (string): Name of the remote plugin to examine. The
| ``:latest`` tag is optional, and is the default if omitted.
|
| Returns:
| A list of dictionaries representing the plugin's
| permissions
|
| plugins(self)
| Retrieve a list of installed plugins.
|
| Returns:
| A list of dicts, one per plugin
|
| pull_plugin(self, remote, privileges, name=None)
| Pull and install a plugin. After the plugin is installed, it can be
| enabled using :py:meth:`~enable_plugin`.
|
| Args:
| remote (string): Remote reference for the plugin to install.
| The ``:latest`` tag is optional, and is the default if
| omitted.
| privileges (:py:class:`list`): A list of privileges the user
| consents to grant to the plugin. Can be retrieved using
| :py:meth:`~plugin_privileges`.
| name (string): Local name for the pulled plugin. The
| ``:latest`` tag is optional, and is the default if omitted.
|
| Returns:
| An iterable object streaming the decoded API logs
|
| push_plugin(self, name)
| Push a plugin to the registry.
|
| Args:
| name (string): Name of the plugin to upload. The ``:latest``
| tag is optional, and is the default if omitted.
|
| Returns:
| ``True`` if successful
|
| remove_plugin(self, name, force=False)
| Remove an installed plugin.
|
| Args:
| name (string): Name of the plugin to remove. The ``:latest``
| tag is optional, and is the default if omitted.
| force (bool): Disable the plugin before removing. This may
| result in issues if the plugin is in use by a container.
|
| Returns:
| ``True`` if successful
|
| upgrade_plugin(self, name, remote, privileges)
| Upgrade an installed plugin.
|
| Args:
| name (string): Name of the plugin to upgrade. The ``:latest``
| tag is optional and is the default if omitted.
| remote (string): Remote reference to upgrade to. The
| ``:latest`` tag is optional and is the default if omitted.
| privileges (:py:class:`list`): A list of privileges the user
| consents to grant to the plugin. Can be retrieved using
| :py:meth:`~plugin_privileges`.
|
| Returns:
| An iterable object streaming the decoded API logs
|
| ----------------------------------------------------------------------
| Methods inherited from docker.api.secret.SecretApiMixin:
|
| create_secret(self, name, data, labels=None, driver=None)
| Create a secret
|
| Args:
| name (string): Name of the secret
| data (bytes): Secret data to be stored
| labels (dict): A mapping of labels to assign to the secret
| driver (DriverConfig): A custom driver configuration. If
| unspecified, the default ``internal`` driver will be used
|
| Returns (dict): ID of the newly created secret
|
| inspect_secret(self, id)
| Retrieve secret metadata
|
| Args:
| id (string): Full ID of the secret to inspect
|
| Returns (dict): A dictionary of metadata
|
| Raises:
| :py:class:`docker.errors.NotFound`
| if no secret with that ID exists
|
| remove_secret(self, id)
| Remove a secret
|
| Args:
| id (string): Full ID of the secret to remove
|
| Returns (boolean): True if successful
|
| Raises:
| :py:class:`docker.errors.NotFound`
| if no secret with that ID exists
|
| secrets(self, filters=None)
| List secrets
|
| Args:
| filters (dict): A map of filters to process on the secrets
| list. Available filters: ``names``
|
| Returns (list): A list of secrets
|
| ----------------------------------------------------------------------
| Methods inherited from docker.api.service.ServiceApiMixin:
|
| create_service(self, task_template, name=None, labels=None, mode=None, update_config=None, networks=None, endpoint_config=None, endpoint_spec=None, rollback_config=None)
| Create a service.
|
| Args:
| task_template (TaskTemplate): Specification of the task to start as
| part of the new service.
| name (string): User-defined name for the service. Optional.
| labels (dict): A map of labels to associate with the service.
| Optional.
| mode (ServiceMode): Scheduling mode for the service (replicated
| or global). Defaults to replicated.
| update_config (UpdateConfig): Specification for the update strategy
| of the service. Default: ``None``
| rollback_config (RollbackConfig): Specification for the rollback
| strategy of the service. Default: ``None``
| networks (:py:class:`list`): List of network names or IDs or
| :py:class:`~docker.types.NetworkAttachmentConfig` to attach the
| service to. Default: ``None``.
| endpoint_spec (EndpointSpec): Properties that can be configured to
| access and load balance a service. Default: ``None``.
|
| Returns:
| A dictionary containing an ``ID`` key for the newly created
| service.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| inspect_service(self, service, insert_defaults=None)
| Return information about a service.
|
| Args:
| service (str): Service name or ID.
| insert_defaults (boolean): If true, default values will be merged
| into the service inspect output.
|
| Returns:
| (dict): A dictionary of the server-side representation of the
| service, including all relevant properties.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| inspect_task(self, task)
| Retrieve information about a task.
|
| Args:
| task (str): Task ID
|
| Returns:
| (dict): Information about the task.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| remove_service(self, service)
| Stop and remove a service.
|
| Args:
| service (str): Service name or ID
|
| Returns:
| ``True`` if successful.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| service_logs(self, service, details=False, follow=False, stdout=False, stderr=False, since=0, timestamps=False, tail='all', is_tty=None)
| Get log stream for a service.
| Note: This endpoint works only for services with the ``json-file``
| or ``journald`` logging drivers.
|
| Args:
| service (str): ID or name of the service
| details (bool): Show extra details provided to logs.
| Default: ``False``
| follow (bool): Keep connection open to read logs as they are
| sent by the Engine. Default: ``False``
| stdout (bool): Return logs from ``stdout``. Default: ``False``
| stderr (bool): Return logs from ``stderr``. Default: ``False``
| since (int): UNIX timestamp for the logs staring point.
| Default: 0
| timestamps (bool): Add timestamps to every log line.
| tail (string or int): Number of log lines to be returned,
| counting from the current end of the logs. Specify an
| integer or ``'all'`` to output all log lines.
| Default: ``all``
| is_tty (bool): Whether the service's :py:class:`ContainerSpec`
| enables the TTY option. If omitted, the method will query
| the Engine for the information, causing an additional
| roundtrip.
|
| Returns (generator): Logs for the service.
|
| services(self, filters=None, status=None)
| List services.
|
| Args:
| filters (dict): Filters to process on the nodes list. Valid
| filters: ``id``, ``name`` , ``label`` and ``mode``.
| Default: ``None``.
| status (bool): Include the service task count of running and
| desired tasks. Default: ``None``.
|
| Returns:
| A list of dictionaries containing data about each service.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| tasks(self, filters=None)
| Retrieve a list of tasks.
|
| Args:
| filters (dict): A map of filters to process on the tasks list.
| Valid filters: ``id``, ``name``, ``service``, ``node``,
| ``label`` and ``desired-state``.
|
| Returns:
| (:py:class:`list`): List of task dictionaries.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| update_service(self, service, version, task_template=None, name=None, labels=None, mode=None, update_config=None, networks=None, endpoint_config=None, endpoint_spec=None, fetch_current_spec=False, rollback_config=None)
| Update a service.
|
| Args:
| service (string): A service identifier (either its name or service
| ID).
| version (int): The version number of the service object being
| updated. This is required to avoid conflicting writes.
| task_template (TaskTemplate): Specification of the updated task to
| start as part of the service.
| name (string): New name for the service. Optional.
| labels (dict): A map of labels to associate with the service.
| Optional.
| mode (ServiceMode): Scheduling mode for the service (replicated
| or global). Defaults to replicated.
| update_config (UpdateConfig): Specification for the update strategy
| of the service. Default: ``None``.
| rollback_config (RollbackConfig): Specification for the rollback
| strategy of the service. Default: ``None``
| networks (:py:class:`list`): List of network names or IDs or
| :py:class:`~docker.types.NetworkAttachmentConfig` to attach the
| service to. Default: ``None``.
| endpoint_spec (EndpointSpec): Properties that can be configured to
| access and load balance a service. Default: ``None``.
| fetch_current_spec (boolean): Use the undefined settings from the
| current specification of the service. Default: ``False``
|
| Returns:
| A dictionary containing a ``Warnings`` key.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| ----------------------------------------------------------------------
| Methods inherited from docker.api.swarm.SwarmApiMixin:
|
| create_swarm_spec(self, *args, **kwargs)
| Create a :py:class:`docker.types.SwarmSpec` instance that can be used
| as the ``swarm_spec`` argument in
| :py:meth:`~docker.api.swarm.SwarmApiMixin.init_swarm`.
|
| Args:
| task_history_retention_limit (int): Maximum number of tasks
| history stored.
| snapshot_interval (int): Number of logs entries between snapshot.
| keep_old_snapshots (int): Number of snapshots to keep beyond the
| current snapshot.
| log_entries_for_slow_followers (int): Number of log entries to
| keep around to sync up slow followers after a snapshot is
| created.
| heartbeat_tick (int): Amount of ticks (in seconds) between each
| heartbeat.
| election_tick (int): Amount of ticks (in seconds) needed without a
| leader to trigger a new election.
| dispatcher_heartbeat_period (int): The delay for an agent to send
| a heartbeat to the dispatcher.
| node_cert_expiry (int): Automatic expiry for nodes certificates.
| external_cas (:py:class:`list`): Configuration for forwarding
| signing requests to an external certificate authority. Use
| a list of :py:class:`docker.types.SwarmExternalCA`.
| name (string): Swarm's name
| labels (dict): User-defined key/value metadata.
| signing_ca_cert (str): The desired signing CA certificate for all
| swarm node TLS leaf certificates, in PEM format.
| signing_ca_key (str): The desired signing CA key for all swarm
| node TLS leaf certificates, in PEM format.
| ca_force_rotate (int): An integer whose purpose is to force swarm
| to generate a new signing CA certificate and key, if none have
| been specified.
| autolock_managers (boolean): If set, generate a key and use it to
| lock data stored on the managers.
| log_driver (DriverConfig): The default log driver to use for tasks
| created in the orchestrator.
|
| Returns:
| :py:class:`docker.types.SwarmSpec`
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| Example:
|
| >>> spec = client.api.create_swarm_spec(
| snapshot_interval=5000, log_entries_for_slow_followers=1200
| )
| >>> client.api.init_swarm(
| advertise_addr='eth0', listen_addr='0.0.0.0:5000',
| force_new_cluster=False, swarm_spec=spec
| )
|
| get_unlock_key(self)
| Get the unlock key for this Swarm manager.
|
| Returns:
| A ``dict`` containing an ``UnlockKey`` member
|
| init_swarm(self, advertise_addr=None, listen_addr='0.0.0.0:2377', force_new_cluster=False, swarm_spec=None, default_addr_pool=None, subnet_size=None, data_path_addr=None, data_path_port=None)
| Initialize a new Swarm using the current connected engine as the first
| node.
|
| Args:
| advertise_addr (string): Externally reachable address advertised
| to other nodes. This can either be an address/port combination
| in the form ``192.168.1.1:4567``, or an interface followed by a
| port number, like ``eth0:4567``. If the port number is omitted,
| the port number from the listen address is used. If
| ``advertise_addr`` is not specified, it will be automatically
| detected when possible. Default: None
| listen_addr (string): Listen address used for inter-manager
| communication, as well as determining the networking interface
| used for the VXLAN Tunnel Endpoint (VTEP). This can either be
| an address/port combination in the form ``192.168.1.1:4567``,
| or an interface followed by a port number, like ``eth0:4567``.
| If the port number is omitted, the default swarm listening port
| is used. Default: '0.0.0.0:2377'
| force_new_cluster (bool): Force creating a new Swarm, even if
| already part of one. Default: False
| swarm_spec (dict): Configuration settings of the new Swarm. Use
| ``APIClient.create_swarm_spec`` to generate a valid
| configuration. Default: None
| default_addr_pool (list of strings): Default Address Pool specifies
| default subnet pools for global scope networks. Each pool
| should be specified as a CIDR block, like '10.0.0.0/8'.
| Default: None
| subnet_size (int): SubnetSize specifies the subnet size of the
| networks created from the default subnet pool. Default: None
| data_path_addr (string): Address or interface to use for data path
| traffic. For example, 192.168.1.1, or an interface, like eth0.
| data_path_port (int): Port number to use for data path traffic.
| Acceptable port range is 1024 to 49151. If set to ``None`` or
| 0, the default port 4789 will be used. Default: None
|
| Returns:
| (str): The ID of the created node.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| inspect_node(self, node_id)
| Retrieve low-level information about a swarm node
|
| Args:
| node_id (string): ID of the node to be inspected.
|
| Returns:
| A dictionary containing data about this node.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| inspect_swarm(self)
| Retrieve low-level information about the current swarm.
|
| Returns:
| A dictionary containing data about the swarm.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| join_swarm(self, remote_addrs, join_token, listen_addr='0.0.0.0:2377', advertise_addr=None, data_path_addr=None)
| Make this Engine join a swarm that has already been created.
|
| Args:
| remote_addrs (:py:class:`list`): Addresses of one or more manager
| nodes already participating in the Swarm to join.
| join_token (string): Secret token for joining this Swarm.
| listen_addr (string): Listen address used for inter-manager
| communication if the node gets promoted to manager, as well as
| determining the networking interface used for the VXLAN Tunnel
| Endpoint (VTEP). Default: ``'0.0.0.0:2377``
| advertise_addr (string): Externally reachable address advertised
| to other nodes. This can either be an address/port combination
| in the form ``192.168.1.1:4567``, or an interface followed by a
| port number, like ``eth0:4567``. If the port number is omitted,
| the port number from the listen address is used. If
| AdvertiseAddr is not specified, it will be automatically
| detected when possible. Default: ``None``
| data_path_addr (string): Address or interface to use for data path
| traffic. For example, 192.168.1.1, or an interface, like eth0.
|
| Returns:
| ``True`` if the request went through.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| leave_swarm(self, force=False)
| Leave a swarm.
|
| Args:
| force (bool): Leave the swarm even if this node is a manager.
| Default: ``False``
|
| Returns:
| ``True`` if the request went through.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| nodes(self, filters=None)
| List swarm nodes.
|
| Args:
| filters (dict): Filters to process on the nodes list. Valid
| filters: ``id``, ``name``, ``membership`` and ``role``.
| Default: ``None``
|
| Returns:
| A list of dictionaries containing data about each swarm node.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| remove_node(self, node_id, force=False)
| Remove a node from the swarm.
|
| Args:
| node_id (string): ID of the node to be removed.
| force (bool): Force remove an active node. Default: `False`
|
| Raises:
| :py:class:`docker.errors.NotFound`
| If the node referenced doesn't exist in the swarm.
|
| :py:class:`docker.errors.APIError`
| If the server returns an error.
| Returns:
| `True` if the request was successful.
|
| unlock_swarm(self, key)
| Unlock a locked swarm.
|
| Args:
| key (string): The unlock key as provided by
| :py:meth:`get_unlock_key`
|
| Raises:
| :py:class:`docker.errors.InvalidArgument`
| If the key argument is in an incompatible format
|
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| Returns:
| `True` if the request was successful.
|
| Example:
|
| >>> key = client.api.get_unlock_key()
| >>> client.unlock_swarm(key)
|
| update_node(self, node_id, version, node_spec=None)
| Update the node's configuration
|
| Args:
|
| node_id (string): ID of the node to be updated.
| version (int): The version number of the node object being
| updated. This is required to avoid conflicting writes.
| node_spec (dict): Configuration settings to update. Any values
| not provided will be removed. Default: ``None``
|
| Returns:
| `True` if the request went through.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| Example:
|
| >>> node_spec = {'Availability': 'active',
| 'Name': 'node-name',
| 'Role': 'manager',
| 'Labels': {'foo': 'bar'}
| }
| >>> client.api.update_node(node_id='24ifsmvkjbyhk', version=8,
| node_spec=node_spec)
|
| update_swarm(self, version, swarm_spec=None, rotate_worker_token=False, rotate_manager_token=False, rotate_manager_unlock_key=False)
| Update the Swarm's configuration
|
| Args:
| version (int): The version number of the swarm object being
| updated. This is required to avoid conflicting writes.
| swarm_spec (dict): Configuration settings to update. Use
| :py:meth:`~docker.api.swarm.SwarmApiMixin.create_swarm_spec` to
| generate a valid configuration. Default: ``None``.
| rotate_worker_token (bool): Rotate the worker join token. Default:
| ``False``.
| rotate_manager_token (bool): Rotate the manager join token.
| Default: ``False``.
| rotate_manager_unlock_key (bool): Rotate the manager unlock key.
| Default: ``False``.
|
| Returns:
| ``True`` if the request went through.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| ----------------------------------------------------------------------
| Methods inherited from docker.api.volume.VolumeApiMixin:
|
| create_volume(self, name=None, driver=None, driver_opts=None, labels=None)
| Create and register a named volume
|
| Args:
| name (str): Name of the volume
| driver (str): Name of the driver used to create the volume
| driver_opts (dict): Driver options as a key-value dictionary
| labels (dict): Labels to set on the volume
|
| Returns:
| (dict): The created volume reference object
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| Example:
|
| >>> volume = client.api.create_volume(
| ... name='foobar',
| ... driver='local',
| ... driver_opts={'foo': 'bar', 'baz': 'false'},
| ... labels={"key": "value"},
| ... )
| ... print(volume)
| {u'Driver': u'local',
| u'Labels': {u'key': u'value'},
| u'Mountpoint': u'/var/lib/docker/volumes/foobar/_data',
| u'Name': u'foobar',
| u'Scope': u'local'}
|
| inspect_volume(self, name)
| Retrieve volume info by name.
|
| Args:
| name (str): volume name
|
| Returns:
| (dict): Volume information dictionary
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| Example:
|
| >>> client.api.inspect_volume('foobar')
| {u'Driver': u'local',
| u'Mountpoint': u'/var/lib/docker/volumes/foobar/_data',
| u'Name': u'foobar'}
|
| prune_volumes(self, filters=None)
| Delete unused volumes
|
| Args:
| filters (dict): Filters to process on the prune list.
|
| Returns:
| (dict): A dict containing a list of deleted volume names and
| the amount of disk space reclaimed in bytes.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| remove_volume(self, name, force=False)
| Remove a volume. Similar to the ``docker volume rm`` command.
|
| Args:
| name (str): The volume's name
| force (bool): Force removal of volumes that were already removed
| out of band by the volume driver plugin.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If volume failed to remove.
|
| volumes(self, filters=None)
| List volumes currently registered by the docker daemon. Similar to the
| ``docker volume ls`` command.
|
| Args:
| filters (dict): Server-side list filtering options.
|
| Returns:
| (dict): Dictionary with list of volume objects as value of the
| ``Volumes`` key.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| Example:
|
| >>> client.api.volumes()
| {u'Volumes': [{u'Driver': u'local',
| u'Mountpoint': u'/var/lib/docker/volumes/foobar/_data',
| u'Name': u'foobar'},
| {u'Driver': u'local',
| u'Mountpoint': u'/var/lib/docker/volumes/baz/_data',
| u'Name': u'baz'}]}
docker.Context
Python Library Documentation: class Context in module docker.context.context class Context(builtins.object) | Context(name, orchestrator=None, host=None, endpoints=None, tls=False) | | A context. | | Methods defined here: | | __call__(self) | Call self as a function. | | __init__(self, name, orchestrator=None, host=None, endpoints=None, tls=False) | Initialize self. See help(type(self)) for accurate signature. | | __repr__(self) | Return repr(self). | | __str__(self) | Return str(self). | | inspect(self) | | is_docker_host(self) | | remove(self) | | save(self) | | set_endpoint(self, name='docker', host=None, tls_cfg=None, skip_tls_verify=False, def_namespace=None) | | ---------------------------------------------------------------------- | Class methods defined here: | | load_context(name) | | ---------------------------------------------------------------------- | Readonly properties defined here: | | Host | | Metadata | | Name | | Orchestrator | | Storage | | TLSConfig | | TLSMaterial | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables | | __weakref__ | list of weak references to the object
docker.ContextAPI
Python Library Documentation: class ContextAPI in module docker.context.api
class ContextAPI(builtins.object)
| Context API.
| Contains methods for context management:
| create, list, remove, get, inspect.
|
| Class methods defined here:
|
| contexts()
| Context list.
| Returns:
| (Context): List of context objects.
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| create_context(name, orchestrator=None, host=None, tls_cfg=None, default_namespace=None, skip_tls_verify=False)
| Creates a new context.
| Returns:
| (Context): a Context object.
| Raises:
| :py:class:`docker.errors.MissingContextParameter`
| If a context name is not provided.
| :py:class:`docker.errors.ContextAlreadyExists`
| If a context with the name already exists.
| :py:class:`docker.errors.ContextException`
| If name is default.
|
| Example:
|
| >>> from docker.context import ContextAPI
| >>> ctx = ContextAPI.create_context(name='test')
| >>> print(ctx.Metadata)
| {
| "Name": "test",
| "Metadata": {},
| "Endpoints": {
| "docker": {
| "Host": "unix:///var/run/docker.sock",
| "SkipTLSVerify": false
| }
| }
| }
|
| get_context(name=None)
| Retrieves a context object.
| Args:
| name (str): The name of the context
|
| Example:
|
| >>> from docker.context import ContextAPI
| >>> ctx = ContextAPI.get_context(name='test')
| >>> print(ctx.Metadata)
| {
| "Name": "test",
| "Metadata": {},
| "Endpoints": {
| "docker": {
| "Host": "unix:///var/run/docker.sock",
| "SkipTLSVerify": false
| }
| }
| }
|
| get_current_context()
| Get current context.
| Returns:
| (Context): current context object.
|
| inspect_context(name='default')
| Remove a context. Similar to the ``docker context inspect`` command.
|
| Args:
| name (str): The name of the context
|
| Raises:
| :py:class:`docker.errors.MissingContextParameter`
| If a context name is not provided.
| :py:class:`docker.errors.ContextNotFound`
| If a context with the name does not exist.
|
| Example:
|
| >>> from docker.context import ContextAPI
| >>> ContextAPI.remove_context(name='test')
| >>>
|
| kwargs_from_context(name=None, environment=None)
| Build ``base_url`` / ``tls`` kwargs from a Docker CLI context.
|
| Mirrors the Docker CLI: if ``name`` is not given, honours the
| ``DOCKER_CONTEXT`` env var, then the ``currentContext`` field in
| ``~/.docker/config.json``, defaulting to the built-in ``default``
| context (local socket / named pipe). On a host with Docker Desktop
| this resolves to the ``desktop-linux`` (or equivalent) context, so
| client construction targets Docker Desktop out of the box.
|
| remove_context(name)
| Remove a context. Similar to the ``docker context rm`` command.
|
| Args:
| name (str): The name of the context
|
| Raises:
| :py:class:`docker.errors.MissingContextParameter`
| If a context name is not provided.
| :py:class:`docker.errors.ContextNotFound`
| If a context with the name does not exist.
| :py:class:`docker.errors.ContextException`
| If name is default.
|
| Example:
|
| >>> from docker.context import ContextAPI
| >>> ContextAPI.remove_context(name='test')
| >>>
|
| set_current_context(name='default')
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| DEFAULT_CONTEXT = <Context: 'default'>
docker.DockerClient
Python Library Documentation: class DockerClient in module docker.client
class DockerClient(builtins.object)
| DockerClient(*args, **kwargs)
|
| A client for communicating with a Docker server.
|
| Example:
|
| >>> import docker
| >>> client = docker.DockerClient(base_url='unix://var/run/docker.sock')
|
| Args:
| base_url (str): URL to the Docker server. For example,
| ``unix:///var/run/docker.sock`` or ``tcp://127.0.0.1:1234``.
| version (str): The version of the API to use. Set to ``auto`` to
| automatically detect the server's version. Default: ``1.35``
| timeout (int): Default timeout for API calls, in seconds.
| tls (bool or :py:class:`~docker.tls.TLSConfig`): Enable TLS. Pass
| ``True`` to enable it with default options, or pass a
| :py:class:`~docker.tls.TLSConfig` object to use custom
| configuration.
| user_agent (str): Set a custom user agent for requests to the server.
| credstore_env (dict): Override environment variables when calling the
| credential store process.
| use_ssh_client (bool): If set to `True`, an ssh connection is made
| via shelling out to the ssh client. Ensure the ssh client is
| installed and configured on the host.
| max_pool_size (int): The maximum number of connections
| to save in the pool.
|
| Methods defined here:
|
| __getattr__(self, name)
|
| __init__(self, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| close(self)
| Closes all adapters and as such the session
|
| df(self)
| Get data usage information.
|
| Returns:
| (dict): A dictionary representing different resource categories
| and their respective data usage.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| events(self, *args, **kwargs)
| Get real-time events from the server. Similar to the ``docker events``
| command.
|
| Args:
| since (UTC datetime or int): Get events from this point
| until (UTC datetime or int): Get events until this point
| filters (dict): Filter the events by event time, container or image
| decode (bool): If set to true, stream will be decoded into dicts on
| the fly. False by default.
|
| Returns:
| A :py:class:`docker.types.daemon.CancellableStream` generator
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| Example:
|
| >>> for event in client.events(decode=True)
| ... print(event)
| {u'from': u'image/with:tag',
| u'id': u'container-id',
| u'status': u'start',
| u'time': 1423339459}
| ...
|
| or
|
| >>> events = client.events()
| >>> for event in events:
| ... print(event)
| >>> # and cancel from another thread
| >>> events.close()
|
| info(self, *args, **kwargs)
| Display system-wide information. Identical to the ``docker info``
| command.
|
| Returns:
| (dict): The info as a dict
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| login(self, *args, **kwargs)
| Authenticate with a registry. Similar to the ``docker login`` command.
|
| Args:
| username (str): The registry username
| password (str): The plaintext password
| email (str): The email for the registry account
| registry (str): URL to the registry. E.g.
| ``https://index.docker.io/v1/``
| reauth (bool): Whether or not to refresh existing authentication on
| the Docker server.
| dockercfg_path (str): Use a custom path for the Docker config file
| (default ``$HOME/.docker/config.json`` if present,
| otherwise ``$HOME/.dockercfg``)
|
| Returns:
| (dict): The response from the login request
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| ping(self, *args, **kwargs)
| Checks the server is responsive. An exception will be raised if it
| isn't responding.
|
| Returns:
| (bool) The response from the server.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| version(self, *args, **kwargs)
| Returns version information from the server. Similar to the ``docker
| version`` command.
|
| Returns:
| (dict): The server version information
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| from_context(name=None, **kwargs)
| Return a client configured from a Docker CLI context.
|
| With no ``name``, resolves the current context the same way the
| Docker CLI does: ``DOCKER_CONTEXT`` env var, then the
| ``currentContext`` field in ``~/.docker/config.json``, falling back
| to the built-in ``default`` context. On a machine with Docker
| Desktop installed this typically resolves to ``desktop-linux``.
|
| Args:
| name (str): Name of the context to load. ``None`` (the default)
| means "use the current context".
| version (str): The version of the API to use. Set to ``auto`` to
| automatically detect the server's version.
| timeout (int): Default timeout for API calls, in seconds.
| max_pool_size (int): The maximum number of connections to save in
| the pool.
| use_ssh_client (bool): If ``True``, shell out to the ssh client
| for ssh:// contexts.
|
| Example:
|
| >>> import docker
| >>> client = docker.DockerClient.from_context()
| >>> # or, pick a specific context:
| >>> client = docker.DockerClient.from_context('desktop-linux')
|
| from_env(**kwargs)
| Return a client configured from environment variables.
|
| The environment variables used are the same as those used by the
| Docker command-line client. They are:
|
| .. envvar:: DOCKER_HOST
|
| The URL to the Docker host.
|
| .. envvar:: DOCKER_TLS_VERIFY
|
| Verify the host against a CA certificate.
|
| .. envvar:: DOCKER_CERT_PATH
|
| A path to a directory containing TLS certificates to use when
| connecting to the Docker host.
|
| Args:
| version (str): The version of the API to use. Set to ``auto`` to
| automatically detect the server's version. Default: ``auto``
| timeout (int): Default timeout for API calls, in seconds.
| max_pool_size (int): The maximum number of connections
| to save in the pool.
| environment (dict): The environment to read environment variables
| from. Default: the value of ``os.environ``
| credstore_env (dict): Override environment variables when calling
| the credential store process.
| use_ssh_client (bool): If set to `True`, an ssh connection is
| made via shelling out to the ssh client. Ensure the ssh
| client is installed and configured on the host.
| use_context (bool): If ``True`` (the default), fall back to the
| current Docker CLI context (``~/.docker/config.json`` /
| ``DOCKER_CONTEXT``) when ``DOCKER_HOST`` is not set. This
| allows the client to talk to Docker Desktop out of the box.
|
| Example:
|
| >>> import docker
| >>> client = docker.from_env()
|
| .. _`SSL version`:
| https://docs.python.org/3.5/library/ssl.html#ssl.PROTOCOL_TLSv1
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| configs
| An object for managing configs on the server. See the
| :doc:`configs documentation <configs>` for full details.
|
| containers
| An object for managing containers on the server. See the
| :doc:`containers documentation <containers>` for full details.
|
| images
| An object for managing images on the server. See the
| :doc:`images documentation <images>` for full details.
|
| networks
| An object for managing networks on the server. See the
| :doc:`networks documentation <networks>` for full details.
|
| nodes
| An object for managing nodes on the server. See the
| :doc:`nodes documentation <nodes>` for full details.
|
| plugins
| An object for managing plugins on the server. See the
| :doc:`plugins documentation <plugins>` for full details.
|
| secrets
| An object for managing secrets on the server. See the
| :doc:`secrets documentation <secrets>` for full details.
|
| services
| An object for managing services on the server. See the
| :doc:`services documentation <services>` for full details.
|
| swarm
| An object for managing a swarm on the server. See the
| :doc:`swarm documentation <swarm>` for full details.
|
| volumes
| An object for managing volumes on the server. See the
| :doc:`volumes documentation <volumes>` for full details.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
docker.TLSConfig
Python Library Documentation: class TLSConfig in module docker.tls class TLSConfig(builtins.object) | TLSConfig(client_cert=None, ca_cert=None, verify=None) | | TLS configuration. | | Args: | client_cert (tuple of str): Path to client cert, path to client key. | ca_cert (str): Path to CA cert file. | verify (bool or str): This can be a bool or a path to a CA cert | file to verify against. If ``True``, verify using ca_cert; | if ``False`` or not specified, do not verify. | | Methods defined here: | | __init__(self, client_cert=None, ca_cert=None, verify=None) | Initialize self. See help(type(self)) for accurate signature. | | configure_client(self, client) | Configure a client with these TLS options. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables | | __weakref__ | list of weak references to the object | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | ca_cert = None | | cert = None | | verify = None
docker.api
Python Library Documentation: package docker.api in docker
NAME
docker.api
PACKAGE CONTENTS
build
client
config
container
daemon
exec_api
image
network
plugin
secret
service
swarm
volume
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\docker\api\__init__.py
docker.auth
Python Library Documentation: module docker.auth in docker
NAME
docker.auth
CLASSES
builtins.dict(builtins.object)
AuthConfig
class AuthConfig(builtins.dict)
| AuthConfig(dct, credstore_env=None)
|
| Method resolution order:
| AuthConfig
| builtins.dict
| builtins.object
|
| Methods defined here:
|
| __init__(self, dct, credstore_env=None)
| Initialize self. See help(type(self)) for accurate signature.
|
| add_auth(self, reg, data)
|
| get_all_credentials(self)
|
| get_credential_store(self, registry)
|
| resolve_authconfig(self, registry=None)
| Returns the authentication data from the given auth configuration for a
| specific registry. As with the Docker client, legacy entries in the
| config with full URLs are stripped down to hostnames before checking
| for a match. Returns None if no match was found.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| load_config(config_path, config_dict, credstore_env=None)
| Loads authentication data from a Docker configuration file in the given
| root directory or if config_path is passed use given path.
| Lookup priority:
| explicit config_path parameter > DOCKER_CONFIG environment
| variable > ~/.docker/config.json > ~/.dockercfg
|
| parse_auth(entries, raise_on_error=False)
| Parses authentication entries
|
| Args:
| entries: Dict of authentication entries.
| raise_on_error: If set to true, an invalid format will raise
| InvalidConfigFile
|
| Returns:
| Authentication registry.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| auths
|
| cred_helpers
|
| creds_store
|
| is_empty
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.dict:
|
| __contains__(self, key, /)
| True if the dictionary has the specified key, else False.
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __ior__(self, value, /)
| Return self|=value.
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __or__(self, value, /)
| Return self|value.
|
| __repr__(self, /)
| Return repr(self).
|
| __reversed__(self, /)
| Return a reverse iterator over the dict keys.
|
| __ror__(self, value, /)
| Return value|self.
|
| __setitem__(self, key, value, /)
| Set self[key] to value.
|
| __sizeof__(...)
| D.__sizeof__() -> size of D in memory, in bytes
|
| clear(...)
| D.clear() -> None. Remove all items from D.
|
| copy(...)
| D.copy() -> a shallow copy of D
|
| get(self, key, default=None, /)
| Return the value for key if key is in the dictionary, else default.
|
| items(...)
| D.items() -> a set-like object providing a view on D's items
|
| keys(...)
| D.keys() -> a set-like object providing a view on D's keys
|
| pop(...)
| D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
|
| If the key is not found, return the default if given; otherwise,
| raise a KeyError.
|
| popitem(self, /)
| Remove and return a (key, value) pair as a 2-tuple.
|
| Pairs are returned in LIFO (last-in, first-out) order.
| Raises KeyError if the dict is empty.
|
| setdefault(self, key, default=None, /)
| Insert key with a value of default if key is not in the dictionary.
|
| Return the value for key if key is in the dictionary, else default.
|
| update(...)
| D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
| If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]
| If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v
| In either case, this is followed by: for k in F: D[k] = F[k]
|
| values(...)
| D.values() -> an object providing a view on D's values
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.dict:
|
| __class_getitem__(...)
| See PEP 585
|
| fromkeys(iterable, value=None, /)
| Create a new dictionary with keys from iterable and values set to value.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.dict:
|
| __new__(*args, **kwargs) class method of builtins.dict
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from builtins.dict:
|
| __hash__ = None
FUNCTIONS
convert_to_hostname(url)
decode_auth(auth)
encode_header(auth)
get_config_header(client, registry)
get_credential_store(authconfig, registry)
load_config(config_path=None, config_dict=None, credstore_env=None)
parse_auth(entries, raise_on_error=False)
Parses authentication entries
Args:
entries: Dict of authentication entries.
raise_on_error: If set to true, an invalid format will raise
InvalidConfigFile
Returns:
Authentication registry.
resolve_authconfig(authconfig, registry=None, credstore_env=None)
resolve_index_name(index_name)
resolve_repository_name(repo_name)
split_repo_name(repo_name)
DATA
INDEX_NAME = 'docker.io'
INDEX_URL = 'https://index.docker.io/v1/'
TOKEN_USERNAME = '<token>'
log = <Logger docker.auth (WARNING)>
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\docker\auth.py
docker.client
Python Library Documentation: module docker.client in docker
NAME
docker.client
CLASSES
builtins.object
DockerClient
class DockerClient(builtins.object)
| DockerClient(*args, **kwargs)
|
| A client for communicating with a Docker server.
|
| Example:
|
| >>> import docker
| >>> client = docker.DockerClient(base_url='unix://var/run/docker.sock')
|
| Args:
| base_url (str): URL to the Docker server. For example,
| ``unix:///var/run/docker.sock`` or ``tcp://127.0.0.1:1234``.
| version (str): The version of the API to use. Set to ``auto`` to
| automatically detect the server's version. Default: ``1.35``
| timeout (int): Default timeout for API calls, in seconds.
| tls (bool or :py:class:`~docker.tls.TLSConfig`): Enable TLS. Pass
| ``True`` to enable it with default options, or pass a
| :py:class:`~docker.tls.TLSConfig` object to use custom
| configuration.
| user_agent (str): Set a custom user agent for requests to the server.
| credstore_env (dict): Override environment variables when calling the
| credential store process.
| use_ssh_client (bool): If set to `True`, an ssh connection is made
| via shelling out to the ssh client. Ensure the ssh client is
| installed and configured on the host.
| max_pool_size (int): The maximum number of connections
| to save in the pool.
|
| Methods defined here:
|
| __getattr__(self, name)
|
| __init__(self, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| close(self)
| Closes all adapters and as such the session
|
| df(self)
| Get data usage information.
|
| Returns:
| (dict): A dictionary representing different resource categories
| and their respective data usage.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| events(self, *args, **kwargs)
| Get real-time events from the server. Similar to the ``docker events``
| command.
|
| Args:
| since (UTC datetime or int): Get events from this point
| until (UTC datetime or int): Get events until this point
| filters (dict): Filter the events by event time, container or image
| decode (bool): If set to true, stream will be decoded into dicts on
| the fly. False by default.
|
| Returns:
| A :py:class:`docker.types.daemon.CancellableStream` generator
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| Example:
|
| >>> for event in client.events(decode=True)
| ... print(event)
| {u'from': u'image/with:tag',
| u'id': u'container-id',
| u'status': u'start',
| u'time': 1423339459}
| ...
|
| or
|
| >>> events = client.events()
| >>> for event in events:
| ... print(event)
| >>> # and cancel from another thread
| >>> events.close()
|
| info(self, *args, **kwargs)
| Display system-wide information. Identical to the ``docker info``
| command.
|
| Returns:
| (dict): The info as a dict
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| login(self, *args, **kwargs)
| Authenticate with a registry. Similar to the ``docker login`` command.
|
| Args:
| username (str): The registry username
| password (str): The plaintext password
| email (str): The email for the registry account
| registry (str): URL to the registry. E.g.
| ``https://index.docker.io/v1/``
| reauth (bool): Whether or not to refresh existing authentication on
| the Docker server.
| dockercfg_path (str): Use a custom path for the Docker config file
| (default ``$HOME/.docker/config.json`` if present,
| otherwise ``$HOME/.dockercfg``)
|
| Returns:
| (dict): The response from the login request
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| ping(self, *args, **kwargs)
| Checks the server is responsive. An exception will be raised if it
| isn't responding.
|
| Returns:
| (bool) The response from the server.
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| version(self, *args, **kwargs)
| Returns version information from the server. Similar to the ``docker
| version`` command.
|
| Returns:
| (dict): The server version information
|
| Raises:
| :py:class:`docker.errors.APIError`
| If the server returns an error.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| from_context(name=None, **kwargs)
| Return a client configured from a Docker CLI context.
|
| With no ``name``, resolves the current context the same way the
| Docker CLI does: ``DOCKER_CONTEXT`` env var, then the
| ``currentContext`` field in ``~/.docker/config.json``, falling back
| to the built-in ``default`` context. On a machine with Docker
| Desktop installed this typically resolves to ``desktop-linux``.
|
| Args:
| name (str): Name of the context to load. ``None`` (the default)
| means "use the current context".
| version (str): The version of the API to use. Set to ``auto`` to
| automatically detect the server's version.
| timeout (int): Default timeout for API calls, in seconds.
| max_pool_size (int): The maximum number of connections to save in
| the pool.
| use_ssh_client (bool): If ``True``, shell out to the ssh client
| for ssh:// contexts.
|
| Example:
|
| >>> import docker
| >>> client = docker.DockerClient.from_context()
| >>> # or, pick a specific context:
| >>> client = docker.DockerClient.from_context('desktop-linux')
|
| from_env(**kwargs)
| Return a client configured from environment variables.
|
| The environment variables used are the same as those used by the
| Docker command-line client. They are:
|
| .. envvar:: DOCKER_HOST
|
| The URL to the Docker host.
|
| .. envvar:: DOCKER_TLS_VERIFY
|
| Verify the host against a CA certificate.
|
| .. envvar:: DOCKER_CERT_PATH
|
| A path to a directory containing TLS certificates to use when
| connecting to the Docker host.
|
| Args:
| version (str): The version of the API to use. Set to ``auto`` to
| automatically detect the server's version. Default: ``auto``
| timeout (int): Default timeout for API calls, in seconds.
| max_pool_size (int): The maximum number of connections
| to save in the pool.
| environment (dict): The environment to read environment variables
| from. Default: the value of ``os.environ``
| credstore_env (dict): Override environment variables when calling
| the credential store process.
| use_ssh_client (bool): If set to `True`, an ssh connection is
| made via shelling out to the ssh client. Ensure the ssh
| client is installed and configured on the host.
| use_context (bool): If ``True`` (the default), fall back to the
| current Docker CLI context (``~/.docker/config.json`` /
| ``DOCKER_CONTEXT``) when ``DOCKER_HOST`` is not set. This
| allows the client to talk to Docker Desktop out of the box.
|
| Example:
|
| >>> import docker
| >>> client = docker.from_env()
|
| .. _`SSL version`:
| https://docs.python.org/3.5/library/ssl.html#ssl.PROTOCOL_TLSv1
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| configs
| An object for managing configs on the server. See the
| :doc:`configs documentation <configs>` for full details.
|
| containers
| An object for managing containers on the server. See the
| :doc:`containers documentation <containers>` for full details.
|
| images
| An object for managing images on the server. See the
| :doc:`images documentation <images>` for full details.
|
| networks
| An object for managing networks on the server. See the
| :doc:`networks documentation <networks>` for full details.
|
| nodes
| An object for managing nodes on the server. See the
| :doc:`nodes documentation <nodes>` for full details.
|
| plugins
| An object for managing plugins on the server. See the
| :doc:`plugins documentation <plugins>` for full details.
|
| secrets
| An object for managing secrets on the server. See the
| :doc:`secrets documentation <secrets>` for full details.
|
| services
| An object for managing services on the server. See the
| :doc:`services documentation <services>` for full details.
|
| swarm
| An object for managing a swarm on the server. See the
| :doc:`swarm documentation <swarm>` for full details.
|
| volumes
| An object for managing volumes on the server. See the
| :doc:`volumes documentation <volumes>` for full details.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
FUNCTIONS
from_context(name=None, **kwargs) class method of DockerClient
Return a client configured from a Docker CLI context.
With no ``name``, resolves the current context the same way the
Docker CLI does: ``DOCKER_CONTEXT`` env var, then the
``currentContext`` field in ``~/.docker/config.json``, falling back
to the built-in ``default`` context. On a machine with Docker
Desktop installed this typically resolves to ``desktop-linux``.
Args:
name (str): Name of the context to load. ``None`` (the default)
means "use the current context".
version (str): The version of the API to use. Set to ``auto`` to
automatically detect the server's version.
timeout (int): Default timeout for API calls, in seconds.
max_pool_size (int): The maximum number of connections to save in
the pool.
use_ssh_client (bool): If ``True``, shell out to the ssh client
for ssh:// contexts.
Example:
>>> import docker
>>> client = docker.DockerClient.from_context()
>>> # or, pick a specific context:
>>> client = docker.DockerClient.from_context('desktop-linux')
from_env(**kwargs) class method of DockerClient
Return a client configured from environment variables.
The environment variables used are the same as those used by the
Docker command-line client. They are:
.. envvar:: DOCKER_HOST
The URL to the Docker host.
.. envvar:: DOCKER_TLS_VERIFY
Verify the host against a CA certificate.
.. envvar:: DOCKER_CERT_PATH
A path to a directory containing TLS certificates to use when
connecting to the Docker host.
Args:
version (str): The version of the API to use. Set to ``auto`` to
automatically detect the server's version. Default: ``auto``
timeout (int): Default timeout for API calls, in seconds.
max_pool_size (int): The maximum number of connections
to save in the pool.
environment (dict): The environment to read environment variables
from. Default: the value of ``os.environ``
credstore_env (dict): Override environment variables when calling
the credential store process.
use_ssh_client (bool): If set to `True`, an ssh connection is
made via shelling out to the ssh client. Ensure the ssh
client is installed and configured on the host.
use_context (bool): If ``True`` (the default), fall back to the
current Docker CLI context (``~/.docker/config.json`` /
``DOCKER_CONTEXT``) when ``DOCKER_HOST`` is not set. This
allows the client to talk to Docker Desktop out of the box.
Example:
>>> import docker
>>> client = docker.from_env()
.. _`SSL version`:
https://docs.python.org/3.5/library/ssl.html#ssl.PROTOCOL_TLSv1
DATA
DEFAULT_MAX_POOL_SIZE = 10
DEFAULT_TIMEOUT_SECONDS = 60
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\docker\client.py
docker.constants
Python Library Documentation: module docker.constants in docker
NAME
docker.constants
DATA
BYTE_UNITS = {'b': 1, 'g': 1073741824, 'k': 1024, 'm': 1048576}
CONTAINER_LIMITS_KEYS = ['memory', 'memswap', 'cpushares', 'cpusetcpus...
DEFAULT_DATA_CHUNK_SIZE = 2097152
DEFAULT_DOCKER_API_VERSION = '1.45'
DEFAULT_HTTP_HOST = '127.0.0.1'
DEFAULT_MAX_POOL_SIZE = 10
DEFAULT_NPIPE = 'npipe:////./pipe/docker_engine'
DEFAULT_NUM_POOLS = 25
DEFAULT_NUM_POOLS_SSH = 9
DEFAULT_SWARM_ADDR_POOL = ['10.0.0.0/8']
DEFAULT_SWARM_SUBNET_SIZE = 24
DEFAULT_TIMEOUT_SECONDS = 60
DEFAULT_UNIX_SOCKET = 'http+unix:///var/run/docker.sock'
DEFAULT_USER_AGENT = 'docker-sdk-python/7.2.0'
INSECURE_REGISTRY_DEPRECATION_WARNING = 'The `insecure_registry` argum...
IS_WINDOWS_PLATFORM = True
MINIMUM_DOCKER_API_VERSION = '1.24'
STREAM_HEADER_SIZE_BYTES = 8
WINDOWS_LONGPATH_PREFIX = r'\\?\'
VERSION
7.2.0
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\docker\constants.py
docker.context
Python Library Documentation: package docker.context in docker
NAME
docker.context
PACKAGE CONTENTS
api
config
context
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\docker\context\__init__.py
docker.credentials
Python Library Documentation: package docker.credentials in docker
NAME
docker.credentials
PACKAGE CONTENTS
constants
errors
store
utils
DATA
DEFAULT_LINUX_STORE = 'secretservice'
DEFAULT_OSX_STORE = 'osxkeychain'
DEFAULT_WIN32_STORE = 'wincred'
PROGRAM_PREFIX = 'docker-credential-'
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\docker\credentials\__init__.py
docker.errors
Python Library Documentation: module docker.errors in docker
NAME
docker.errors
CLASSES
builtins.Exception(builtins.BaseException)
DockerException
APIError(requests.exceptions.HTTPError, DockerException)
NotFound
ImageNotFound
BuildError
ContainerError
ContextAlreadyExists
ContextException
ContextNotFound
DeprecatedMethod
ImageLoadError
InvalidArgument
InvalidConfigFile
InvalidRepository
InvalidVersion
MissingContextParameter
NullResource(DockerException, builtins.ValueError)
TLSParameterError
builtins.RuntimeError(builtins.Exception)
StreamParseError
requests.exceptions.HTTPError(requests.exceptions.RequestException)
APIError(requests.exceptions.HTTPError, DockerException)
NotFound
ImageNotFound
class APIError(requests.exceptions.HTTPError, DockerException)
| APIError(message, response=None, explanation=None)
|
| An HTTP error from the API.
|
| Method resolution order:
| APIError
| requests.exceptions.HTTPError
| requests.exceptions.RequestException
| builtins.OSError
| DockerException
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, message, response=None, explanation=None)
| Initialize RequestException with `request` and `response` objects.
|
| __str__(self)
| Return str(self).
|
| is_client_error(self)
|
| is_error(self)
|
| is_server_error(self)
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| status_code
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Data descriptors inherited from requests.exceptions.RequestException:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.OSError:
|
| __reduce__(...)
| Helper for pickle.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.OSError:
|
| __new__(*args, **kwargs) class method of builtins.OSError
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.OSError:
|
| characters_written
|
| errno
| POSIX exception code
|
| filename
| exception filename
|
| filename2
| second exception filename
|
| strerror
| exception strerror
|
| winerror
| Win32 exception code
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class BuildError(DockerException)
| BuildError(reason, build_log)
|
| Method resolution order:
| BuildError
| DockerException
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, reason, build_log)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Data descriptors inherited from DockerException:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class ContainerError(DockerException)
| ContainerError(container, exit_status, command, image, stderr)
|
| Represents a container that has exited with a non-zero exit code.
|
| Method resolution order:
| ContainerError
| DockerException
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, container, exit_status, command, image, stderr)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Data descriptors inherited from DockerException:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class ContextAlreadyExists(DockerException)
| ContextAlreadyExists(name)
|
| Method resolution order:
| ContextAlreadyExists
| DockerException
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, name)
| Initialize self. See help(type(self)) for accurate signature.
|
| __str__(self)
| Return str(self).
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Data descriptors inherited from DockerException:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class ContextException(DockerException)
| ContextException(msg)
|
| Method resolution order:
| ContextException
| DockerException
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, msg)
| Initialize self. See help(type(self)) for accurate signature.
|
| __str__(self)
| Return str(self).
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Data descriptors inherited from DockerException:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class ContextNotFound(DockerException)
| ContextNotFound(name)
|
| Method resolution order:
| ContextNotFound
| DockerException
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, name)
| Initialize self. See help(type(self)) for accurate signature.
|
| __str__(self)
| Return str(self).
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Data descriptors inherited from DockerException:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class DeprecatedMethod(DockerException)
| Method resolution order:
| DeprecatedMethod
| DockerException
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Data descriptors inherited from DockerException:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.Exception:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class DockerException(builtins.Exception)
| A base class from which all other exceptions inherit.
|
| If you want to catch all errors that the Docker SDK might raise,
| catch this base exception.
|
| Method resolution order:
| DockerException
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.Exception:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class ImageLoadError(DockerException)
| Method resolution order:
| ImageLoadError
| DockerException
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Data descriptors inherited from DockerException:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.Exception:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class ImageNotFound(NotFound)
| ImageNotFound(message, response=None, explanation=None)
|
| Method resolution order:
| ImageNotFound
| NotFound
| APIError
| requests.exceptions.HTTPError
| requests.exceptions.RequestException
| builtins.OSError
| DockerException
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from APIError:
|
| __init__(self, message, response=None, explanation=None)
| Initialize RequestException with `request` and `response` objects.
|
| __str__(self)
| Return str(self).
|
| is_client_error(self)
|
| is_error(self)
|
| is_server_error(self)
|
| ----------------------------------------------------------------------
| Readonly properties inherited from APIError:
|
| status_code
|
| ----------------------------------------------------------------------
| Data descriptors inherited from requests.exceptions.RequestException:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.OSError:
|
| __reduce__(...)
| Helper for pickle.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.OSError:
|
| __new__(*args, **kwargs) class method of builtins.OSError
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.OSError:
|
| characters_written
|
| errno
| POSIX exception code
|
| filename
| exception filename
|
| filename2
| second exception filename
|
| strerror
| exception strerror
|
| winerror
| Win32 exception code
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class InvalidArgument(DockerException)
| Method resolution order:
| InvalidArgument
| DockerException
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Data descriptors inherited from DockerException:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.Exception:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class InvalidConfigFile(DockerException)
| Method resolution order:
| InvalidConfigFile
| DockerException
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Data descriptors inherited from DockerException:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.Exception:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class InvalidRepository(DockerException)
| Method resolution order:
| InvalidRepository
| DockerException
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Data descriptors inherited from DockerException:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.Exception:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class InvalidVersion(DockerException)
| Method resolution order:
| InvalidVersion
| DockerException
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Data descriptors inherited from DockerException:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.Exception:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class MissingContextParameter(DockerException)
| MissingContextParameter(param)
|
| Method resolution order:
| MissingContextParameter
| DockerException
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, param)
| Initialize self. See help(type(self)) for accurate signature.
|
| __str__(self)
| Return str(self).
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Data descriptors inherited from DockerException:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class NotFound(APIError)
| NotFound(message, response=None, explanation=None)
|
| Method resolution order:
| NotFound
| APIError
| requests.exceptions.HTTPError
| requests.exceptions.RequestException
| builtins.OSError
| DockerException
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from APIError:
|
| __init__(self, message, response=None, explanation=None)
| Initialize RequestException with `request` and `response` objects.
|
| __str__(self)
| Return str(self).
|
| is_client_error(self)
|
| is_error(self)
|
| is_server_error(self)
|
| ----------------------------------------------------------------------
| Readonly properties inherited from APIError:
|
| status_code
|
| ----------------------------------------------------------------------
| Data descriptors inherited from requests.exceptions.RequestException:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.OSError:
|
| __reduce__(...)
| Helper for pickle.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.OSError:
|
| __new__(*args, **kwargs) class method of builtins.OSError
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.OSError:
|
| characters_written
|
| errno
| POSIX exception code
|
| filename
| exception filename
|
| filename2
| second exception filename
|
| strerror
| exception strerror
|
| winerror
| Win32 exception code
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class NullResource(DockerException, builtins.ValueError)
| Method resolution order:
| NullResource
| DockerException
| builtins.ValueError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Data descriptors inherited from DockerException:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.ValueError:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.ValueError:
|
| __new__(*args, **kwargs) class method of builtins.ValueError
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class StreamParseError(builtins.RuntimeError)
| StreamParseError(reason)
|
| Method resolution order:
| StreamParseError
| builtins.RuntimeError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, reason)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.RuntimeError:
|
| __new__(*args, **kwargs) class method of builtins.RuntimeError
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class TLSParameterError(DockerException)
| TLSParameterError(msg)
|
| Method resolution order:
| TLSParameterError
| DockerException
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, msg)
| Initialize self. See help(type(self)) for accurate signature.
|
| __str__(self)
| Return str(self).
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Data descriptors inherited from DockerException:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.Exception:
|
| __new__(*args, **kwargs) class method of builtins.Exception
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
FUNCTIONS
create_api_error_from_http_exception(e)
Create a suitable APIError from requests.exceptions.HTTPError.
create_unexpected_kwargs_error(name, kwargs)
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\docker\errors.py
docker.from_context
Python Library Documentation: method from_context in module docker.client
from_context(name=None, **kwargs) class method of docker.client.DockerClient
Return a client configured from a Docker CLI context.
With no ``name``, resolves the current context the same way the
Docker CLI does: ``DOCKER_CONTEXT`` env var, then the
``currentContext`` field in ``~/.docker/config.json``, falling back
to the built-in ``default`` context. On a machine with Docker
Desktop installed this typically resolves to ``desktop-linux``.
Args:
name (str): Name of the context to load. ``None`` (the default)
means "use the current context".
version (str): The version of the API to use. Set to ``auto`` to
automatically detect the server's version.
timeout (int): Default timeout for API calls, in seconds.
max_pool_size (int): The maximum number of connections to save in
the pool.
use_ssh_client (bool): If ``True``, shell out to the ssh client
for ssh:// contexts.
Example:
>>> import docker
>>> client = docker.DockerClient.from_context()
>>> # or, pick a specific context:
>>> client = docker.DockerClient.from_context('desktop-linux')
docker.from_env
Python Library Documentation: method from_env in module docker.client
from_env(**kwargs) class method of docker.client.DockerClient
Return a client configured from environment variables.
The environment variables used are the same as those used by the
Docker command-line client. They are:
.. envvar:: DOCKER_HOST
The URL to the Docker host.
.. envvar:: DOCKER_TLS_VERIFY
Verify the host against a CA certificate.
.. envvar:: DOCKER_CERT_PATH
A path to a directory containing TLS certificates to use when
connecting to the Docker host.
Args:
version (str): The version of the API to use. Set to ``auto`` to
automatically detect the server's version. Default: ``auto``
timeout (int): Default timeout for API calls, in seconds.
max_pool_size (int): The maximum number of connections
to save in the pool.
environment (dict): The environment to read environment variables
from. Default: the value of ``os.environ``
credstore_env (dict): Override environment variables when calling
the credential store process.
use_ssh_client (bool): If set to `True`, an ssh connection is
made via shelling out to the ssh client. Ensure the ssh
client is installed and configured on the host.
use_context (bool): If ``True`` (the default), fall back to the
current Docker CLI context (``~/.docker/config.json`` /
``DOCKER_CONTEXT``) when ``DOCKER_HOST`` is not set. This
allows the client to talk to Docker Desktop out of the box.
Example:
>>> import docker
>>> client = docker.from_env()
.. _`SSL version`:
https://docs.python.org/3.5/library/ssl.html#ssl.PROTOCOL_TLSv1
docker.models
Python Library Documentation: package docker.models in docker
NAME
docker.models
PACKAGE CONTENTS
configs
containers
images
networks
nodes
plugins
resource
secrets
services
swarm
volumes
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\docker\models\__init__.py
docker.tls
Python Library Documentation: module docker.tls in docker
NAME
docker.tls
CLASSES
builtins.object
TLSConfig
class TLSConfig(builtins.object)
| TLSConfig(client_cert=None, ca_cert=None, verify=None)
|
| TLS configuration.
|
| Args:
| client_cert (tuple of str): Path to client cert, path to client key.
| ca_cert (str): Path to CA cert file.
| verify (bool or str): This can be a bool or a path to a CA cert
| file to verify against. If ``True``, verify using ca_cert;
| if ``False`` or not specified, do not verify.
|
| Methods defined here:
|
| __init__(self, client_cert=None, ca_cert=None, verify=None)
| Initialize self. See help(type(self)) for accurate signature.
|
| configure_client(self, client)
| Configure a client with these TLS options.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| ca_cert = None
|
| cert = None
|
| verify = None
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\docker\tls.py
docker.transport
Python Library Documentation: package docker.transport in docker
NAME
docker.transport
PACKAGE CONTENTS
basehttpadapter
npipeconn
npipesocket
sshconn
unixconn
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\docker\transport\__init__.py
docker.types
Python Library Documentation: package docker.types in docker
NAME
docker.types
PACKAGE CONTENTS
base
containers
daemon
healthcheck
networks
services
swarm
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\docker\types\__init__.py
docker.utils
Python Library Documentation: package docker.utils in docker
NAME
docker.utils
PACKAGE CONTENTS
build
config
decorators
fnmatch
json_stream
ports
proxy
socket
utils
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\docker\utils\__init__.py
docker.version
Python Library Documentation: module docker.version in docker
NAME
docker.version
VERSION
7.2.0
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\docker\version.py