Python调用Docker API

最新推荐文章于 2023-12-15 21:05:00 发布
最新推荐文章于 2023-12-15 21:05:00 发布
阅读量509 收藏 2
点赞数
文章标签： python docker 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45456777/article/details/131920074
版权

调用方式

# api方式
data = {
	"base_url": "tcp://ip:port",
    "sign": "api",
    "apiversion": ""
}
# 实例化对象
tt = DockerManage(**data)

# ssh方式,必须指定apiversion版本号
data = {
	"base_url": "ssh://username:password@ip:port",
    "sign": "ssh",
    "apiversion": "1.23"
}
# 实例化对象
tt = DockerManage(**data)

# 获取容器所有列表
tt.ContainerList()

# 获取镜像列表
tt.Images()

# 拉取镜像
tt.pullimage(tag="镜像id或者镜像名称:镜像")

脚本内容

from io import BytesIO
import os
import docker
from docker import transport, DockerClient
from config import MIN_DOCKER_API, DEFAULT_NUM_POOLS, DEFAULT_MAX_POOL_SIZE

# docker 配置
MIN_DOCKER_API = "1.21"
DEFAULT_NUM_POOLS = 25
DEFAULT_MAX_POOL_SIZE = 30


class SSHHTTPAdapter(transport.SSHHTTPAdapter):
    def __init__(self, ssh_params, timeout=60, pool_connections=DEFAULT_NUM_POOLS,
                 max_pool_size=DEFAULT_MAX_POOL_SIZE, shell_out=False):
        self.ssh_params = ssh_params
        del ssh_params['scheme']
        super(SSHHTTPAdapter, self).__init__('', timeout, pool_connections, max_pool_size, shell_out)
    def _create_paramiko_client(self, _):
        # logging.getLogger("paramiko").setLevel(logging.WARNING)
        self.ssh_client = paramiko.SSHClient()
        ssh_config_file = os.path.expanduser("~/.ssh/config")
        if os.path.exists(ssh_config_file):
            conf = paramiko.SSHConfig()
            with open(ssh_config_file) as f:
                conf.parse(f)
            host_config = conf.lookup(self.ssh_params['hostname'])
            self.ssh_conf = host_config
            if 'proxycommand' in host_config:
                self.ssh_params["sock"] = paramiko.ProxyCommand(
                    self.ssh_conf['proxycommand']
                )
            if 'hostname' in host_config:
                self.ssh_params['hostname'] = host_config['hostname']
            if self.ssh_params['port'] is None and 'port' in host_config:
                self.ssh_params['port'] = self.ssh_conf['port']
            if self.ssh_params['username'] is None and 'user' in host_config:
                self.ssh_params['username'] = self.ssh_conf['user']

        self.ssh_client.load_system_host_keys()
        self.ssh_client.set_missing_host_key_policy(paramiko.WarningPolicy())


class SSHDockerClient(DockerClient):
    def __init__(self, *args, **kwargs):
        base_url = kwargs.get('base_url')
        ssh_params = docker_urlparse(base_url)
        adapter = SSHHTTPAdapter(ssh_params)
        kwargs['base_url'] = ''
        kwargs['version'] = kwargs.get('version')
        super(SSHDockerClient, self).__init__(*args, **kwargs)
        self.api.mount('http+docker://ssh', adapter)
        self.api.base_url = 'http+docker://ssh'


def docker_urlparse(url):
    # fix for url with '#'
    mark = '_a5s7m3_'
    r = urlparse(url.replace('#', mark))
    hostname = r.hostname.replace(mark, '#')
    username = r.username.replace(mark, '#')
    password = r.password.replace(mark, '#')
    port = r.port
    scheme = r.scheme
    return {
        'hostname': hostname,
        'port': port,
        'username': username,
        'password': decrypt(password[2:-1]),
        'scheme': scheme
    }


class DockerManage:
    def __init__(self, *args, **kwargs) -> None:
        self.base_url = kwargs.get("base_url")
        self.sign = kwargs.get("sign")
        self.apiversion = kwargs.get("apiversion")
        self.success_code = 200
        self.fail_code = 400
    
    # 初始化docker连接对象
    def Client(self):
        if self.sign == "api":
            docker_clinet = docker.DockerClient(base_url=self.base_url)
            return docker_clinet
        elif self.sign == "ssh":
            docker_clinet = SSHDockerClient(base_url=self.base_url,version=self.apiversion)
            return docker_clinet

    
    # 获取容器
    def ContainerList(self):
        try:
            client = self.Client()
            container_list = client.api.containers(all=True)
            client.close()
            containers = []
            if container_list:
                for container in container_list:
                    id = container["Id"]
                    names = container["Names"][0].split("/")[1]
                    image = container["Image"]
                    if container["Ports"]:
                        ports = []
                        for ptp in container["Ports"]:
                            if "PublicPort" in ptp.keys():
                                pstr = ptp["IP"] + ":" + str(ptp["PublicPort"]) + "->" + str(ptp["PrivatePort"])
                                ports.append(pstr)
                    else:
                        ports = container["Ports"]
                    status = container["State"]
                    created = TimeTool(container["Created"])
                    
                    if container["Mounts"]:
                        mount = []
                        for mtp in container["Mounts"]:
                            if mtp["Source"]:
                                mtp_str = mtp["Source"] + ":" + mtp["Destination"]
                                mount.append(mtp_str)
                    else:
                        mount = container["Mounts"]
                    container_dict = {"id": id, "name": names, "image": image, "ports": ports, "status": status, "mount": mount, "created": created}
                    containers.append(container_dict)
            return  {"code": self.success_code, "msg": "获取成功","data": containers}    
        except Exception as e:
            return  {"code": self.fail_code, "msg": "获取失败 %s" % str(e),"data": []}    
                

    # 返回本地镜像列表: 镜像tag 镜像大小 镜像创建时间
    def Images(self):
        try:
            client = self.Client()
            images = client.api.images(all=True)
            client.close()
            imagesRes = []
            for image in images:
                created = TimeTool(image["Created"])
                size = HumConvert(image["Size"])
                for tag in image["RepoTags"]:
                    imagesRes.append({"tag": tag, "size": size, "created": created})
            return {"code": self.success_code, "msg": "获取成功", "data": imagesRes}
        except Exception as e:
            return  {"code": self.fail_code, "msg": "获取失败 %s" % str(e),"data": []}    

    # 拉取镜像
    def pullimage(self, tag):
        try:
            client = self.Client()
            client.images.pull(repository=tag)
            client.close()
            return {"code": self.success_code, "msg": "拉取成功", "data": ""}
        except Exception as e:
            return  {"code": self.fail_code, "msg": "拉取失败： " ,"data": [e]}  

    # 删除镜像
    def DelImage(self,tag):
        try:
            client = self.Client()
            client.images.remove(image=tag)
            client.close()
            return {"code": self.success_code, "msg": "删除成功", "data": []}
        except Exception as e:
            return  {"code": self.fail_code, "msg": "删除失败： %s" % str(e),"data": []}  

    # 镜像搜索
    def SearchImg(self,tag):
        try:
            client = self.Client()
            res = client.images.search(tag)
            client.close()
            return {"code": self.success_code, "msg": "查询成功", "data": res}
        except Exception as e:
            return  {"code": self.fail_code, "msg": "查询失败： %s" % str(e),"data": []}  

    # 镜像历史
    def historyImg(self,tag):
        try:
            client = self.Client()
            res = client.api.history(tag)
            client.close()
            return {"code": self.success_code, "msg": "查询成功", "data": res}
        except Exception as e:
            return  {"code": self.fail_code, "msg": "查询失败： %s" % str(e),"data": []} 
    

    # 提交镜像
    def pushImg(self, repository):
        try:
            client = self.Client()
            res = client.api.push(repository=repository)
            client.close()
            return {"code": self.success_code, "msg": "提交成功", "data": res}
        except Exception as e:
            return  {"code": self.fail_code, "msg": "提交失败： %s" % str(e),"data": []}   

    # 重命名镜像
    def tagImg(self, image, repository):
        try:
            client = self.Client()
            res = client.api.tag(image=image, repository=repository)
            client.close()
            return {"code": self.success_code, "msg": "提交成功", "data": res}
        except Exception as e:
            return  {"code": self.fail_code, "msg": "提交失败： %s" % str(e),"data": []}  
    
    # 扩展提交镜像
    def extPush(self, image, repository):
        try:
            client = self.Client()
            res = client.api.tag(image=image, repository=repository)
            if res:
                pres = client.api.push(repository=repository)
                client.close()
                return {"code": self.success_code, "msg": "提交成功", "data": pres}
            else:
                return  {"code": self.fail_code, "msg": "提交失败： %s" % str(res),"data": []}  
        except Exception as e:
            return  {"code": self.fail_code, "msg": "提交失败： %s" % str(e),"data": []}  

    # 重命名容器
    def RenameContainers(self, oldname, newname):
        try:
            client = self.Client()
            client.api.rename(oldname, newname)
            client.close()
            return {"code": self.success_code, "msg": "重命名成功", "data": []}
        except Exception as e:
            return  {"code": self.fail_code, "msg": "重命名失败： %s" % str(e),"data": []}  

    # 重启容器
    def RestartContainers(self, id):
        try:
            client = self.Client()
            client.api.restart(id)
            client.close()
            return {"code": self.success_code, "msg": "重启成功", "data": []}
        except Exception as e:
            return  {"code": self.fail_code, "msg": "重启失败： %s" % str(e),"data": []}  

    # 启动容器
    def StartContainers(self, id):
        try:
            client = self.Client()
            client.api.start(id)
            client.close()
            return {"code": self.success_code, "msg": "启动成功", "data": []}
        except Exception as e:
            return  {"code": self.fail_code, "msg": "启动失败： %s" % str(e),"data": []}  
    
    # 停止容器
    def StopContainers(self, id):
        try:
            client = self.Client()
            client.api.stop(id)
            client.close()
            
            return {"code": self.success_code, "msg": "停止成功", "data": []}
        except Exception as e:
            return  {"code": self.fail_code, "msg": "停止失败： %s" % str(e),"data": []}  

    # 删除容器
    def RemoveContainers(self, id):
        try:
            stopRes = self.StopContainers(id)
            if stopRes["code"] == 200:
                client = self.Client()
                client.api.remove_container(id)
                client.close()
                return {"code": self.success_code, "msg": "删除成功", "data": []}
            else:
                return {"code": self.fail_code, "msg": "删除失败： %s" % stopRes['msg'],"data": []}  
        except Exception as e:
            return  {"code": self.fail_code, "msg": "删除失败： %s" % str(e),"data": []}  
    
    # 创建容器
    def RunContainers(self, data):
        try:
            client = self.Client()
            if ";" in data["binds"]:
                volumes = data["binds"].split(";")
            elif ":" in [data["binds"]]:
                volumes = [data["binds"]]
            else:
                volumes = []
            prots = {}
            if ";" in data["port_bindings"]:
                portLst = data["port_bindings"].split(";")
                prots = {}
                for port in portLst:
                    key = port.split(":")[1]
                    value = port.split(":")[0]
                    prots[key] = value
            elif data["port_bindings"]:
                key = data["port_bindings"].split(":")[1]
                value = data["port_bindings"].split(":")[0]
                prots[key] = value
            if data["nano_cpus"]:
                nano_cpus = int(data["nano_cpus"]) * 1000000000
            else:
                nano_cpus = ""
            
            if ";" in data["environment"]:
                environment = data["environment"].split(";")
            elif ":" in data["environment"]:
                environment = [data["environment"]]
            else:
                environment = []

            container = client.containers.create(
                image=data["image"],
                environment=environment,
                hostname=data["hostname"],
                name=data["name"],
                nano_cpus=nano_cpus,
                mem_limit=data["mem_limit"],
                network=data["network"],
                volumes=volumes,
                ports=prots,
                detach=True,
                network_mode=data["network_mode"],
                restart_policy=data["restart_policy"],
                shm_size=data["shmsize"]
            )
            container.start()
            client.close()
            return {"code": self.success_code, "msg": "创建成功： %s" % container.id,"data": []} 
        except Exception as e:
            return  {"code": self.fail_code, "msg": "创建失败： %s" % str(e),"data": []}  

    # 构建镜像
    def build(self, dockerfile, tag):
        try:
            client = self.Client()
            f = BytesIO(dockerfile.encode('utf-8'))
            response = [line for line in client.api.build(fileobj=f, rm=True, tag=tag, nocache=True)]
            res_data = eval（response[-1])
            client.close()
            if "Successfully tagged" in str(res_data):
                return {"code": self.success_code, "msg": "build成功", "data": [res_data]}
            else:
                return  {"code": self.fail_code, "msg": "build失败" ,"data": [res_data]}  
            
        except Exception as e:
            return  {"code": self.fail_code, "msg": "build失败： %s" % str(e),"data": []}
一只小丑个
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
neo4j_fastapi_docker:在此存储库中，您可以使用FastAPI框架找到一个小型python API，并使用其Cypher Query Language（CQL）与neo4j数据库配合使用。
03-22
neo4j_fastapi_docker 安装泊坞窗 安装docker-compose 运行docekr-compose $ docker-compose build $ docker-compose up
docker-compose-linux-x86_64
09-21
Docker-Compose项目是Docker官方的开源项目，负责实现对Docker容器集群的快速编排。 Docker-Compose将所管理的容器分为三层，分别是工程（project），服务（service）以及容器（container）。Docker-Compose运行目录下的所有文件（docker-compose.yml，extends文件或环境变量文件等）组成一个工程，若无特殊指定工程名即为当前目录名。一个工程当中可包含多个服务，每个服务中定义了容器运行的镜像、参数、依赖。一个服务当中可包括多个容器实例，Docker-Compose并没有解决负载均衡的问题，因此需要借助其它工具实现服务发现及负载均衡，比如 Consul。 Compose允许用户通过一个单独的docker-compose.yml模板文件（YAML 格式）来定义一组相关联的应用容器为一个项目（project）。 Docker-Compose项目由Python编写，调用Docker服务提供的API来对容器进行管理。因此，只要所操作的平台支持Docker API， 就可以在其上利用Compose来进行编排管理。
flask-ansible:Flask Restful Service使用Ansible2 Python API在远程主机上运行任务
05-13
烧瓶可用 用法 首先，您需要创建一个SSH密钥对，在远程主机上复制公共密钥，并将私有密钥复制到该项目中的空id_rsa文件中。 在工作站上生成并运行示例应用程序： docker build -t flask-ansible . sudo docker run -p 80:80/tcp flask-ansible 现在，在浏览器上打开 ，或仅使用curl调用示例应用程序上的唯一方法： curl 'localhost/?host=srvX.example,srvY.example' 该命令使用Ansible在srvX.example和srvY.example主机上运行以下两个任务： 27 ... 28 dict(action=dict(module='shell', args="hostname -f")), 29 dict(action=dict(module='yum', arg
Python-一个封装DockerEngineAPI的Python库
08-12
一个封装 Docker Engine API 的Python库。 实现在Python应用程序中执行 - 运行容器，管理容器，管理Swarms等，它允许您执行docker命令所能做的所有任何事情。
docker-py 用Python调用Docker接口的方法
09-18
今天小编就为大家分享一篇docker-py 用Python调用Docker接口的方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
docker python api 安装配置的详解
01-09
docker python api 安装配置的详解 1.docker宿主机配置文件修改 $vim /etc/default/docker #再已有OPTS中添加 DOCKER_OPTS=-H tcp://0.0.0.0:2375 -H unix://var/run/docker.sock 使得可以通过tcp的2375端口连接到docker守护进程中，第二个-H及之后的内容可以省略 2.安装docker-py $sudo pip install docker-py 3.编写api脚本 参考文档 http://docker-py.readthedocs.org/en/lates
【Python】Python调用Docker API
qq_35061334的博客
01-19 7473
介绍 用于 Docker 引擎 API 的 Python 库。它允许您执行docker命令所做的任何事情，但可以在 Python 应用程序中执行——运行容器、管理容器、管理 Swarm 等。 docker-py git项目地址. 安装 pip install docker 如果您打算通过 TLS 连接到 docker 主机，docker[tls]请改为添加您的要求，或使用 pip 安装： pip install docker[tls] 用法 1、使用默认套接字或环境中的配置连接到 Docker： imp
python docker api_Docker的Python库API
weixin_42513616的博客
12-30 1571
您可以使用python库API访问，管理和操作Docker对象，例如容器，图像，集群，群集等。您可以执行docker命令可以执行的几乎所有操作。当您使用django或flask之类的python应用程序并且要使用与该应用程序相同的python脚本维护docker容器时，这非常方便。要为docker使用python库API，您需要安装一个名为docker-py的软件包。您可以使用以下pip命令执行此...
docker-py(Docker SDK for Python)使用指南
夏小悠的博客
02-08 5469
本篇博客围绕官方提供的`python`版的`docker Engine API(Docker SDK for Python)`，结合具体示例，详细介绍如何使用`python`来自动化操作`docker`。
python调用docker接口（待验证）
最新发布
潇洒哥的运维之道
12-15 182
【代码】python调用docker接口（待验证）
Python调用Docker API远程访问Linux下的Docker
cafocc的博客
01-04 3889
客户端，Windows，python 3.5，PyCharm 服务器端，CentOS7.2，docker 18.09.0 一、docker开放远程连接，修改/usr/lib/systemd/system/docker.service文件。 vim /usr/lib/systemd/system/docker.service 在文件中找到[service] [Service] ExecS...
十一、Docker API
margu_168的博客
06-06 1065
一般来说，只要一个架构的设计满足REST，就可以称之为RESTful的架构，Docker API的设计也是满足REST风格的。类似GitHub的管理，本节暂不进行讨论。： 诸如docker run等操作最终都是通过调用Docker Remote API向Docker daemon 发起请求的，使用它我们可以远程操作docker容器，更重要的是可以通过程序自动化运维docker进程。：与镜像存储有关的操作可以通过Docker Registry API来完成，可以自由的自动化、程序化的管理你的镜像仓库。
一个Python项目（带前端），部署到Docker的完整过程
热门推荐
u013282737的博客
12-25 3万+
前提: docker已经安装好，docker的安装，请见另一篇博客： https://blog.csdn.net/u013282737/article/details/85246755 序言：介绍一下需要运行的Python项目的结构： 平时在PyCharm里面运行该工程，只要直接运行server.py文件即可 现在希望将该工程，部署到docker里面，使用容器启动： ...
python操作docker
发呆的比目鱼的博客
11-19 3108
python操作docker
Python调用Docker
DemingLiu的博客
08-05 415
Python 调用Docker API， 容器数据卷挂载，gpu共享，端口映射
python docker api_Docker 系列（八）：Docker API使用
weixin_33110431的博客
02-09 713
Docker API种类docker官方主要有三大对外api：Docker Registry APIDocker Hub APIDocker Remote API1. Docker Registry API这个是docker镜像仓库的api，通过操作这套API，你可以自由的自动化、程序化的管理你的镜像仓库。2. Docker Hub APIDocker Hub API是用户管理操作的API，doc...
python docker api_docker python api 安装配置的详解
weixin_39640849的博客
12-20 158
docker python api 安装配置的详解1.docker宿主机配置文件修改$vim /etc/default/docker #再已有OPTS中添加DOCKER_OPTS="-H tcp://0.0.0.0:2375 -H unix://var/run/docker.sock"使得可以通过tcp的2375端口连接到docker守护进程中，第二个-H及之后的内容可以省略2.安装docker-...
pythondockerapi_docker-py 用Python调用Docker接口的方法
weixin_39533742的博客
11-30 194
官方文档：【https://docker-py.readthedocs.io/en/stable/images.html】众所周知，Docker向外界提供了一个API来管理其中的资源。这个API可以是socket文件形式的（一般也是默认的，在/var/run/docker.sock中），也可以是TCP形式的。以前想要通过编程的方法来调用这些API还是傻傻的用subprocess等和系统层面交互的模...
Python开发加薪利器之Docker的使用
WANGJUNAIJIAO的博客
10-16 1010
Docker为什么火，因为十分的轻巧。Docker是基于Go语言开发的。
Python调用Docker接口
05-27
是的，使用 `docker-py` 模块可以通过Python代码来调用Docker的API接口。下面是一个简单的代码示例，可以列出当前系统上所有的Docker镜像： ``` import docker # 创建Docker客户端 client = docker.from_env() # ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值