使用go实现docker简易版

最新推荐文章于 2024-08-12 09:02:10 发布
最新推荐文章于 2024-08-12 09:02:10 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： docker golang 文章标签： golang docker centos
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36688622/article/details/111187203
版权

文章目录

写在前面

本blog是基于《自己动手写docker》一书的实验笔记，与原书本的生产环境和golang版本都不同，所以会导致各种bug，本文针对这些进行了修复。

系统环境

测试环境

[root@iz2zegp1t778mbekgw2rdrz fs]# lsb_release -a
LSB Version:    :core-4.1-amd64:core-4.1-noarch
Distributor ID: CentOS
Description:    CentOS Linux release 7.3.1611 (Core) 
Release:        7.3.1611
Codename:       Core
[root@iz2zegp1t778mbekgw2rdrz fs]# uname -r
3.10.0-514.26.2.el7.x86_64
[root@iz2zegp1t778mbekgw2rdrz fs]# go version
go version go1.13.5 linux/amd64
[root@iz2zegp1t778mbekgw2rdrz fs]# docker -v
Docker version 19.03.12, build 48a66213fe

Namespace

概念

是Kernel的一个功能，主要用于资源隔离，当前Linux支持六种Namespace

Namespace版本系统调用参数内核版本
UTS NamespaceCLONE_NEWUTS2.6.19
IPC NamespaceCLONE_NEWIPC2.6.19
Mount NamespaceCLONE_NEWNS2.4.19
User NamespaceCLONE_NEWUTS3.8
PID NamespaceCLONE_NEWPID2.6.24
Network NamespaceCLONE_NEWUTS2.6.29

Namespace 的API主要由下列三个调用

  • clone()：创建新process，由参数来确定被创建的n、Namespace的类型，并且其子进程也会被包含到Namespace中。
  • unshare()：将进程移出某个Namespace。
  • setns()：将进程加入某个Namespace中。

6个Namespace

UTS Namespace

UTS Namespace（UNIX Time-sharing System Namespace）主要用来隔离nodename和domainname这两个系统标识。在每个UTS Namespace中，每个Namespace允许拥有自己的hostname。

代码实现：

func UTSNS() {
    cmd := exec.Command("sh")
    
    // 笔者使用的是MACOS，服务器是阿里云。如果使用goland等IDE，IDE自动识别当前系统为Darwin，下面这个struct会报错，但是不用管他。
    cmd.SysProcAttr = &syscall.SysProcAttr{
        Cloneflags: syscall.CLONE_NEWUTS,
    }
    cmd.Stdin = os.Stdin
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr

    if err := cmd.Run(); err != nil {
        log.Fatal(err)
    }
}

运行代码，进入交互式终端，使用pstree -pl查看当前的进程树

[root@iz2zegp1t778mbekgw2rdrz docker]# go run main.go 
sh-4.2# pstree -pl
├─sshd(17408)───bash(17410)───go(17546)─┬─main(17571)─┬─sh(17574)───pstree(17575)

可以看到，父进程为main(17571)，子进程为sh(17574)。
查看它们是否在同一个UTS Namespace中

sh-4.2# readlink /proc/17571/ns/uts 
uts:[4026531838]
sh-4.2# readlink /proc/17574/ns/uts 
uts:[4026532220]

的确不在同一个UTS Namespace中，接下来验证hostname是否可以隔离。

sh-4.2# hostname -b hu5ky
sh-4.2# hostname
hu5ky

可见当前shell中的hostname为hu5ky。重新开启一个shell

[root@iz2zegp1t778mbekgw2rdrz home]# hostname
iz2zegp1t778mbekgw2rdrz

可见当前主机的hostname为iz2zegp1t778mbekgw2rdrz，因此hostname隔离成立。

IPC Namespace

IPC Namespace是用来隔离system V mq和POSIX mq的。每一个IPC Namespace都有自己的system V mq和POSIX mq。

代码实现:

func IPCNS() {
    cmd := exec.Command("sh")
    cmd.SysProcAttr = &syscall.SysProcAttr{
        Cloneflags: syscall.CLONE_NEWUTS | syscall.CLONE_NEWIPC,
    }
    cmd.Stdin = os.Stdin
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr

    if err := cmd.Run(); err != nil {
        log.Fatal(err)
    }
}

开启两个shell来验证IPC的资源隔离
首先在宿主机打开一个shell：

[root@iz2zegp1t778mbekgw2rdrz ~]# ipcs -q

------ Message Queues --------
key        msqid      owner      perms      used-bytes   messages

可以看到目前没有ipc，接下来创建一个新的ipc：

[root@iz2zegp1t778mbekgw2rdrz ~]# ipcmk -Q
Message queue id: 0
[root@iz2zegp1t778mbekgw2rdrz ~]# ipcs -q

------ Message Queues --------
key        msqid      owner      perms      used-bytes   messages    
0x7e9ce120 0          root       644        0            0

打开另一个shell：

[root@iz2zegp1t778mbekgw2rdrz docker]# go run main.go 
sh-4.2# ipcs -q

------ Message Queues --------
key        msqid      owner      perms      used-bytes   messages

可以看到，在运行了main.go进入sh后，使用ipcs -q查询的ipc为空，因此宿主机和开启的新终端ipc资源隔离，并且IPC Namespace创建成功。

Mount Namespace

Mount Namespace用来隔离各个进程的挂载点视图。也就是说，在Mount Namespace中使用mount或者umount不会影响其他进程的挂载。因为Mount Namespace是第一个支持的Namespace，所以其系统调用参数为NEWNS（New Namespace）。

代码实现：

func MountNS() {
    cmd := exec.Command("sh")
    syscall.Mount("", "/", "", syscall.MS_PRIVATE|syscall.MS_REC, "")
    cmd.SysProcAttr = &syscall.SysProcAttr{
        Cloneflags: syscall.CLONE_NEWUTS | syscall.CLONE_NEWIPC | syscall.CLONE_NEWPID | syscall.CLONE_NEWNS,
    }
    cmd.Stdin = os.Stdin
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr

    if err := cmd.Run(); err != nil {
        log.Fatal(err)
    }
}

/proc作用是实现进程和内核之间通信。首先运行代码，查看/proc中的资源：

sh-4.2# ls /proc/
1      17729  18481  238  328   460  765        cmdline      interrupts  locks         scsi           uptime
10     18     18493  239  338   462  766        consoles     iomem       mdstat        self           version
10423  18292  18515  241  356   464  795        cpuinfo      ioports     meminfo       slabinfo       vmallocinfo
106    18298  18518  25   37    465  797        crypto       irq         misc          softirqs       vmstat
12     18300  18520  253  370   489  798        devices      kallsyms    modules       stat           zoneinfo
13     18317  19     258  39    490  8          diskstats    kcore       mounts        swaps
14     18319  1928   259  40    5    9          dma          keys        mtrr          sys
15     18394  2      26   4031  6    908        driver       key-users   net           sysrq-trigger
15494  18396  215    27   41    60   acpi       execdomains  kmsg        pagetypeinfo  sysvipc
15526  18431  216    28   430   7    buddyinfo  fb           kpagecount  partitions    timer_list
16     18433  236    29   451   700  bus        filesystems  kpageflags  sched_debug   timer_stats
17     18479  237    3    454   763  cgroups    fs           loadavg     schedstat     tty

可以看见目前由大量的资源信息，因为目前/proc中还是宿主机的资源信息，我们将其挂载到当前进程：

sh-4.2# mount -t proc proc /proc
sh-4.2# ls /proc/
1          consoles   execdomains  irq         kpageflags  mounts        scsi      sysrq-trigger  vmallocinfo
4          cpuinfo    fb           kallsyms    loadavg     mtrr          self      sysvipc        vmstat
acpi       crypto     filesystems  kcore       locks       net           slabinfo  timer_list     zoneinfo
buddyinfo  devices    fs           keys        mdstat      pagetypeinfo  softirqs  timer_stats
bus        diskstats  interrupts   key-users   meminfo     partitions    stat      tty
cgroups    dma        iomem        kmsg        misc        sched_debug   swaps     uptime
cmdline    driver     ioports      kpagecount  modules     schedstat     sys       version

可以看到，现在少了很多的资源信息，我们查看一下当前的进程信息：

sh-4.2# ps -ef
UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 11:44 pts/1    00:00:00 sh
root         5     1  0 11:47 pts/1    00:00:00 ps -ef

可以看到当前的ps命令查看的信息中，sh进程的PID为1，实现了挂载隔离，docker volume就是借助这个特性实现的。

User Namespace

User Namespace主要作用是用来隔离当前用户的用户组ID，一个进程在User Namespace内外的User ID和Group ID可以是不同的，比较常用的作用是使一个非root用户在一个User Namespace中以root权限去调度资源。Linux Kernel >=3.8支持非root用户创建一个User Namespace。

代码实现：

func USERNS() {
    cmd := exec.Command("sh")
    cmd.SysProcAttr = &syscall.SysProcAttr{
        Cloneflags: syscall.CLONE_NEWUTS | syscall.CLONE_NEWIPC | syscall.CLONE_NEWPID | syscall.CLONE_NEWNS |
            syscall.CLONE_NEWUSER,
        UidMappings: []syscall.SysProcIDMap{
            {
                ContainerID: 1234,
                HostID:      syscall.Getuid(),
                Size:        1,
            },
        },
        GidMappings: []syscall.SysProcIDMap{
            {
                ContainerID: 1234,
                HostID:      syscall.Getgid(),
                Size:        1,
            },
        },

    }
    //cmd.SysProcAttr.Credential = &syscall.Credential{Uid: uint32(1), Gid: uint32(1)} // 和之前的版本不一样
    cmd.Stdin = os.Stdin
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr

    if err := cmd.Run(); err != nil {
        log.Fatal(err)
    }
    os.Exit(-1)
}

首先在运行前看一下当前用户在宿主机的id信息。

[root@iz2zegp1t778mbekgw2rdrz docker]# id
uid=0(root) gid=0(root) groups=0(root)

运行代码查看id信息：

sh-4.2$ id
uid=1234 gid=1234 groups=1234

uid，gid，groups不同，User Namespace生效。

PID Namespace

PID Namespace用来隔离进程的ID，在不同的PID Namespace中同一个进程拥有不同的PID。当进入一个docker container时，使用ps -ef查看到当前的进程PID为1，但是在宿主机查看时，PID并不为1，这就是PID Namespace的作用。

代码实现：

func PIDNS() {
    cmd := exec.Command("sh")
    cmd.SysProcAttr = &syscall.SysProcAttr{
        Cloneflags: syscall.CLONE_NEWUTS | syscall.CLONE_NEWIPC | syscall.CLONE_NEWPID,
    }
    cmd.Stdin = os.Stdin
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr

    if err := cmd.Run(); err != nil {
        log.Fatal(err)
    }
}

我们需要打开两个shell终端来验证。
首先打开宿主机的shell：

[root@iz2zegp1t778mbekgw2rdrz ~]# pstree -pl
├─sshd(18317)───bash(18319)───go(18440)─┬─main(18462)─┬─sh(18465)

可以看到当前的sh的PID为18465，接下来运行main.go的终端来查看PID：

[root@iz2zegp1t778mbekgw2rdrz docker]# go run main.go 
sh-4.2# echo $$
1

可以看到当前的PID为1，也就是说宿主机的PID映射到当前的进程是PID为1，PID Namespace创建成功。

**NOTICE：**在sh终端内不能使用ps命令，因为ps，top等命令会用到/proc资源。因为当前的sh中/proc资源还是宿主机的资源，需要使用mount挂在到当前Namespace中才能看到当前的PID。

Network Namespace

Network Namespace是用来隔离网络设备，IP，端口等网络栈的Namespace。Network Namespace可以使当前命名空间拥有自己独立的（虚拟的）网络设备，各个Namespace之间的端口都不会冲突。

代码实现：

func NETNS() {
    cmd := exec.Command("sh")
    syscall.Mount("", "/", "", syscall.MS_PRIVATE|syscall.MS_REC, "")
    cmd.SysProcAttr = &syscall.SysProcAttr{
        Cloneflags: syscall.CLONE_NEWUTS | syscall.CLONE_NEWIPC | syscall.CLONE_NEWPID | syscall.CLONE_NEWNS |
            syscall.CLONE_NEWUSER | syscall.CLONE_NEWNET,
        UidMappings: []syscall.SysProcIDMap{
            {
                ContainerID: 1234,
                HostID:      syscall.Getuid(),
                Size:        1,
            },
        },
        GidMappings: []syscall.SysProcIDMap{
            {
                ContainerID: 1234,
                HostID:      syscall.Getgid(),
                Size:        1,
            },
        },
    }
    //cmd.SysProcAttr.Credential = &syscall.Credential{Uid: uint32(1), Gid: uint32(1)} // 和之前的版本不一样
    cmd.Stdin = os.Stdin
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr

    if err := cmd.Run(); err != nil {
        log.Fatal(err)
    }
    os.Exit(-1)
}

首先查看一下宿主机的网卡信息：

[root@iz2zegp1t778mbekgw2rdrz docker]# ifconfig
docker0: flags=4099<UP,BROADCAST,MULTICAST>  mtu 1500
        inet 172.18.0.1  netmask 255.255.0.0  broadcast 172.18.255.255
        ether 02:42:ed:46:5e:70  txqueuelen 0  (Ethernet)
        RX packets 0  bytes 0 (0.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 172.17.203.111  netmask 255.255.240.0  broadcast 172.17.207.255
        ether 00:16:3e:34:01:d3  txqueuelen 1000  (Ethernet)
        RX packets 5105  bytes 2556002 (2.4 MiB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 3632  bytes 5609285 (5.3 MiB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
        inet 127.0.0.1  netmask 255.0.0.0
        loop  txqueuelen 1  (Local Loopback)
        RX packets 0  bytes 0 (0.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

可以看到有三个网络设备，然后运行main.go查看网络设备：

[root@iz2zegp1t778mbekgw2rdrz docker]# go run main.go 
sh-4.2$ ifconfig
sh-4.2$

可以看到当前是没有任何的网络设备的，因此Network Namespace生效。

铁面无情哈士奇
关注
专栏目录
【云原生之Docker实战】使用Docker部署Syncthing同步程序及基本使用
jks212454的博客
08-16 1240
【云原生之Docker实战】使用Docker部署Syncthing同步程序及基本使用
【打工日常】使用docker部署个人实时在线文档协助编辑器
全糖少冰我吃不了苦
03-09 1358
Etherpad是一个高度可定制的开源在线编辑器，提供真正实时的协作编辑。放在自己的服务器里面，可以更大程度的保护自己工作的隐私，并且Etherpad允许您实时协作编辑文档，就像在浏览器中运行的实时多人编辑器一样这样不管是工作摸鱼在协助文档聊天或者游戏，还是说我们自己开发东西保持一定的安全性提供了保障，毕竟是部署在自己的环境上，相对来说比放在别人的db安全的。本次实践简介本次实践部署环境为个人测试环境本地环境规划。
Go实现自己的Docker
kinglay_007的博客
06-06 982
参考微信号 跟派大星学编程 七天用 Go 写个 docker 环境配置 编译器：Goland2022.1 Go：1.18.1 编译器交叉配置：File=>Settings=>Go=>Build Tags&Vendoring OS修改为linux 下面是实现Docker原理 Go 实现进程隔离 Linux 对线程提供了六种隔离机制，分别为：uts pid user mount network ipc ，它们的作用如下： uts: 用来隔离主机名 pid：用来隔离
自己动手写docker-2
weixin_34247299的博客
10-23 436
2.基础技术 2.1 linux namespace namespace 方便隔离一系列系统资源，pid,user_id, network等，(chroot 创造目录监狱) user_id:因为不同的用户很多时候会需要root权限，不可能都授予他们，namespace可以做user_id级别的隔离，使用户在namespace里面是有root权限的 pid:每个namespace都有一个ini...
Gohangout：高效的数据处理利器
最新发布
gitblog_00371的博客
08-12 323
Gohangout：高效的数据处理利器 gohangout使用 golang 模仿的 Logstash。用于消费 Kafka 数据，处理后写入 ES、Clickhouse 等。项目地址:https://gitcode.com/gh_mirrors/go/gohangout 在数据处理的海洋中，寻找一款既高效又灵活的工具是每个开发者的梦想。今天，我要向大家推荐一款开源项目——Gohangout，它...
分享：用 Go 从头实现一个迷你 Docker—Gocker
zouduchen的博客
02-09 338
　　容器很受欢迎。容器已成为应用程序在服务器上打包和运行的默认方式，最初是由 Docker 普及的。现在，Docker 是公司的名称和一个命令（一组命令），使您可以轻松管理容器（创建，运行，删除，网络）。但是，容器本身是从一组操作系统原语创建的。在本文中，我们将关注 Linux 操作系统上的容器，并简单地说明为什么Windows 上的容器[1]根本不存在。 　　Linux 下没有创建容器的单个系统调用。它们是利用 Linux 命名空间和控制组或 cgroups 构成的松散构造。 　　Gocker[2]
从无到有 - 用Go实现一个docker
fa1c4的blog
12-06 1767
前言 出于对开发经验的需要, 和本着只有亲自创造的才是真正理解的费曼学习精神, 我准备写一个系列的从无到有的各类项目开发blog, 一是记录编程过程, 遇到的问题, 个人领悟, 二是自我督促去做基础开发, 积累开发经验, 理解各个常用软件的实现原理, 三是水blogs 这里用golang完成一个简易docker, 直接从源码层面去理解容器的原理 开发 演示 总结 理解 坑点复盘 参考 https://www.infoq.com/articles/build-a-container-golang/ ...
go操作Docker
一个菜鸟的博客
03-27 1949
Docker介绍 Docker是一个开源的应用容器引擎,让开发者可以打包他们的应用以及依赖包到一个可移植的镜像中,然后发布到任何流行的Linux或Windows操作系统的机器上,也可以实现虚拟化.容器是完全使用沙箱机制,相互之间不会有任何接口. go操作Docker package main import ( "context" "fmt" "github.com/docker/cli/cli/connhelper" "github.com/docker/docker/api/types" "g
采用`Go`语言和`Markdown`实现的一个简易博客系统.zip
02-28
这是一个使用Go语言（Golang）开发的简易博客系统，它采用了Markdown语法来撰写和展示文章内容。Markdown是一种轻量级的标记语言，使得用户能够用易读易写的纯文本格式编写文档，然后转换成结构化的HTML（超文本标记...
Docker
qq_36985354的博客
09-05 501
一、Docker简介 1、Docker为什么会出现？ 一款产品从开发到上线，从操作系统到运行环境，再到应用配置。作为开发+运维之 间的协作需要关心很多东西，这也是很多互联网公司不得不面对的问题，特别是各种版本迭代之后，不同版本环境的兼容，对运维人员都是考验。产品上线的最后一步是部署，互联网高并发的环境和大流量的访问，现在都是采用集群的方式，对运维人员来说，他可能需要反复的去安装配置。 对于上述问题，Docker给出了标准化的解决方案，从根本上解决...
flask+mysql+docker搭建简易网站
weixin_45772001的博客
10-15 1077
flask+mysql+docker网站搭建
七天用Go写个docker（第二天）
跟派大星学编程
03-18 1220
1. Cgroup概念 Linux Cgroup提供了对一组进程及子进程的资源限制，控制和统计的能力，这些资源包括CPU，内存，存储，网络等。通过Cgroup，可以方便的吸纳之某个进程的资源占用，并且可以实时监控进程和统计信息。 Cgroup完成资源限制主要通过下面三个组件 cgroup: 是对进程分组管理的一种机制 subsystem: 是一组资源控制的模块 hierarchy: 把一组c...
七天用Go写个docker（网络篇）
跟派大星学编程
02-15 638
0.docker网络实现 docker网络分为两部分，一部分是docker与宿主机之间的通信，另一部分是docker与外部网络之间的通信。docker与宿主机之间的通信是通过veth和bridge虚拟网络接口实现的，而与外部网络通信是通过 iptables 流量转发实现的。 1. veth和bridge veth是一个虚拟的网络设备，它都是成对出现的，你可以把它理解成马里奥里面的水管，马里奥从一个水管进去，会从另一个水管里面出来，在这里，马里奥就是流量，这两个水管就是一对veth，我们看下实际操作 先创
七天用Go写个docker（第四天）
跟派大星学编程
03-21 791
镜像 前面我们用namespace和cgroup构建了一个简单的容器，但是我们可以发现容器内的目录还是当前运行程序的目录，这里就缺少了镜像这么一个重要的特性。这里我们先用docker拉一个最精简的镜像busybox，它是一个集合了非常多unix工具的箱子，提供了一个非常完整而且小巧的系统。 # 拉取busybox docker pull busybox # 运行 docker run -d b...
七天用Go写个docker（第三天）
跟派大星学编程
03-19 991
项目源码：点击查看项目源码 前面两天我们了解完docker原理之后，今天我们动手把项目的结构给搭起来，先总体看一下项目结构 整个文件调用过程如下 我们最终达到的效果实现下面这个命令，该命令会启动一个隔离的容器，并在该容器中运行第一个命令为 top go-docker run -ti top main.go 程序的入口，主要是接收命令行参数，接收命令行参数处理使用的第三方工具包为gith...
【go语言微服务实践】#3-docker实现一键部署
LittleRong_G的博客
02-17 766
线上答题系统，微服务架构的小小实践，项目代码 一、概述   微服务的部署有下列几种方式：单主机多服务实例模式、每个主机一个服务实例模式、Serverless部署。这里选择的是在docker容器中部署每一个模块的微服务，因为使用容器可以实现快速启动，方便增加和删除某个模块服务实例，且受操作系统的影响比较小。当然，众多容器的管理也有些挑战。   最终我们的系统架构图如下，其中每个圆圈就是一个独立的...
Docker容器化实战第七课 Golang自编Docker
fegus的博客
05-29 661
17 原理实践：自己动手使用 Golang 开发 Docker（上） 第一模块，我们从 Docker 基础概念讲到 Docker 的基本操作。第二模块，我们详细剖析了 Docker 的三大关键技术（ Namespace、cgroups 和联合文件系统）的实现原理，并且讲解了 Docker 的网络模型等关键性技术。相信此时的你已经对 Docker 有了一个新的认识。 接下来的两课时，我就趁热打铁，带你动手使用 Golang 编写一个 Docker。学习这两节的内容需要你能够熟练使用 Golang 语言，如果
笔记 | 用go写个docker
Trollz的博客
06-13 1117
仅作为自己学习过程的记录，不具备参考价值！
GO docker 部署
weixin_44177216的博客
09-30 228
GO docker 部署编辑Dockerfile第一种 直接编译执行第二种 配置docker-compose.yml ，再执行 编辑Dockerfile FROM golang:1.15 AS builder ENV GO111MODULE=on \ GOPROXY=https://goproxy.cn,direct \ CGO_ENABLED=0 \ GOARCH=amd64 # 移动到工作目录：/build WORKDIR /build COPY go.mod . COPY
使用java实现docker命令行
05-30
使用Java实现Docker命令行可以通过Docker Java API来完成。Docker Java API是一个Java客户端，可以与Docker REST API进行交互，从而通过Java代码来管理Docker容器和镜像。 下面是使用Java实现Docker命令行的大致步骤： 1. 引入Docker Java API的依赖，例如在Maven中添加以下依赖： ``` <dependency> <groupId>com.github.docker-java</groupId> <artifactId>docker-java</artifactId> <version>3.2.8</version> </dependency> ``` 2. 创建Docker客户端对象： ``` DockerClient dockerClient = DockerClientBuilder.getInstance().build(); ``` 3. 使用Docker客户端对象来执行Docker命令，例如列出所有容器： ``` List<Container> containers = dockerClient.listContainersCmd().exec(); for (Container container : containers) { System.out.println(container.getId()); } ``` 4. 根据需要进行其他Docker操作，例如启动、停止、创建、删除容器等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值