golang中对于docker sdk的使用

本文涉及到使用golang docker sdk 进行 pull、exec、push、import等常见操作的教程，对官方文档缺失的示例进行了补充。
docker sdk 官方文档：https://docs.docker.com/engine/api/sdk/examples/

docker client 初始化

docker client 有多种初始化方法， 本文使用从env中读取的方式。

client, _ := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())

push

push到私有镜像库时，需要登陆信息。很多小伙伴就是在这里遇到了问题。
首先定义认证数据结构题，需要用户名和密码。

import 	"github.com/docker/docker/api/types"
	authConfig := types.AuthConfig{
		Username: user,
		Password: password,
	}

使用base64编码

	encodedJSON, err := json.Marshal(authConfig)
	if err != nil {
		return "", err
	}

	authStr := base64.URLEncoding.EncodeToString(encodedJSON)

最后调用client

	
	reader, err := client.ImagePush(ctx, image, types.ImagePushOptions{RegistryAuth: authStr})
	if err != nil {
		return "", err
	}
	buf := new(bytes.Buffer)
	buf.ReadFrom(reader)
	// 回显字符
	buf.String()

pull

docker pull私有镜像库时,同样需要认证信息。但是我在测试时发现， pull方法会调用系统中docker认证信息。

	authConfig := types.AuthConfig{
		Username: user,
		Password: password,
	}
	encodedJSON, err := json.Marshal(authConfig)
	if err != nil {
		return "", err
	}

	authStr := base64.URLEncoding.EncodeToString(encodedJSON)
	reader, err := client.ImagePull(ctx, image, types.ImagePullOptions{RegistryAuth: authStr})
	if err != nil {
		return "", err
	}
	buf := new(bytes.Buffer)
	buf.ReadFrom(reader)
	buf.String()

import

import 为将宿主机上的镜像文件导入到docker中，操作比较简单，但是需要打开一个文件。

// file 为打包的镜像文件路径
f, err := os.Open(file)
	defer f.Close()
	if err != nil {
		return "", err
	}

	reader, err := client.ImageImport(ctx, types.ImageImportSource{Source: f, SourceName: "-"}, image, types.ImageImportOptions{})
	if err != nil {
		return "", err
	}
	buf := new(bytes.Buffer)
	buf.ReadFrom(reader)
	buf.String()

copy

copy操作为将宿主机的文件复制到容器中，同样需要读取文件，但是会相对复杂。
首先获取文件相关信息.

	srcPath := file
	dstPath := dest
	dstInfo := archive.CopyInfo{Path: dstPath}
	dstStat, err := d.client.ContainerStatPath(ctx, container, dstPath)

	if err == nil && dstStat.Mode&os.ModeSymlink != 0 {
		linkTarget := dstStat.LinkTarget
		if !system.IsAbs(linkTarget) {
			// Join with the parent directory.
			dstParent, _ := archive.SplitPathDirEntry(dstPath)
			linkTarget = filepath.Join(dstParent, linkTarget)
		}

		dstInfo.Path = linkTarget
		dstStat, err = d.client.ContainerStatPath(ctx, container, linkTarget)
	}

	if err == nil {
		dstInfo.Exists, dstInfo.IsDir = true, dstStat.Mode.IsDir()
	}

定义io对象，读取文件

	var (
		content         io.Reader
		resolvedDstPath string
	)

	// Prepare source copy info.
	srcInfo, err := archive.CopyInfoSourcePath(srcPath, true)
	if err != nil {
		return err
	}

	srcArchive, err := archive.TarResource(srcInfo)
	if err != nil {
		return err
	}
	defer srcArchive.Close()

	dstDir, preparedArchive, err := archive.PrepareArchiveCopy(srcArchive, srcInfo, dstInfo)
	if err != nil {
		return err
	}
	defer preparedArchive.Close()

	resolvedDstPath = dstDir
	content = preparedArchive

默认不允许覆写， 需要使用选项配置。不需要则忽略此项。

	options := types.CopyToContainerOptions{
		AllowOverwriteDirWithFile: true,
	}

最后调用功能

client.CopyToContainer(ctx, container, resolvedDstPath, content, options)

exec

exec为命令执行操作，针对实际使用场景会分为需要返回命令返回值和不需要的情况，这里示例为需要返回值。
首先创建一个命令执行对象

id, err := client.ContainerExecCreate(ctx, container, types.ExecConfig{Tty: true, WorkingDir: chdir, Cmd: cmd, Env: env, AttachStderr: true, AttachStdout: true})
	if err != nil {
		return "", err
	}

执行命令

	resp, err := .client.ContainerExecAttach(ctx, id.ID, types.ExecStartCheck{})
	if err != nil {
		return "", err
	}
	buf := new(bytes.Buffer)
	buf.ReadFrom(resp.Reader)

封装

上文举例了几个相对比较复杂的调用，其他的调用可以参考下面的封装。

package speciality

import (
	"bytes"
	"context"
	"encoding/base64"
	"encoding/json"
	"github.com/docker/docker/api/types"
	"github.com/docker/docker/api/types/container"
	"github.com/docker/docker/client"
	"github.com/docker/docker/pkg/archive"
	"github.com/docker/docker/pkg/system"
	"github.com/docker/go-connections/nat"
	"io"
	"os"
	"path/filepath"
	"time"
)

type Docker struct {
	client *client.Client
}

func NewDocker(c *client.Client) *Docker {
	return &Docker{
		client: c,
	}
}

func (d Docker) Pull(ctx context.Context, image, user, password string) (string, error) {
	authConfig := types.AuthConfig{
		Username: user,
		Password: password,
	}
	encodedJSON, err := json.Marshal(authConfig)
	if err != nil {
		return "", err
	}

	authStr := base64.URLEncoding.EncodeToString(encodedJSON)
	reader, err := d.client.ImagePull(ctx, image, types.ImagePullOptions{RegistryAuth: authStr})
	if err != nil {
		return "", err
	}
	buf := new(bytes.Buffer)
	_, _ = buf.ReadFrom(reader)
	return buf.String(), nil
}

func (d Docker) Import(ctx context.Context, file string, image string) (string, error) {
	f, err := os.Open(file)
	defer f.Close()
	if err != nil {
		return "", err
	}

	reader, err := d.client.ImageImport(ctx, types.ImageImportSource{Source: f, SourceName: "-"}, image, types.ImageImportOptions{})
	if err != nil {
		return "", err
	}
	buf := new(bytes.Buffer)
	_, _ = buf.ReadFrom(reader)
	return buf.String(), nil
}

func (d Docker) Run(ctx context.Context, name string, image string, cmd []string, volumes map[string]struct{}, ports nat.PortSet) error {
	resp, err := d.client.ContainerCreate(ctx, &container.Config{Image: image, Volumes: volumes, ExposedPorts: ports, Cmd: cmd}, nil, nil, nil, name)
	if err != nil {
		return err
	}
	if err = d.client.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
		return err
	}
	return nil
}

func (d Docker) Copy(ctx context.Context, file string, dest string, container string) error {
	srcPath := file
	dstPath := dest
	// Prepare destination copy info by stat-ing the container path.
	dstInfo := archive.CopyInfo{Path: dstPath}
	dstStat, err := d.client.ContainerStatPath(ctx, container, dstPath)

	// If the destination is a symbolic link, we should evaluate it.
	if err == nil && dstStat.Mode&os.ModeSymlink != 0 {
		linkTarget := dstStat.LinkTarget
		if !system.IsAbs(linkTarget) {
			// Join with the parent directory.
			dstParent, _ := archive.SplitPathDirEntry(dstPath)
			linkTarget = filepath.Join(dstParent, linkTarget)
		}

		dstInfo.Path = linkTarget
		dstStat, err = d.client.ContainerStatPath(ctx, container, linkTarget)
	}

	if err == nil {
		dstInfo.Exists, dstInfo.IsDir = true, dstStat.Mode.IsDir()
	}

	var (
		content         io.Reader
		resolvedDstPath string
	)

	// Prepare source copy info.
	srcInfo, err := archive.CopyInfoSourcePath(srcPath, true)
	if err != nil {
		return err
	}

	srcArchive, err := archive.TarResource(srcInfo)
	if err != nil {
		return err
	}
	defer srcArchive.Close()

	dstDir, preparedArchive, err := archive.PrepareArchiveCopy(srcArchive, srcInfo, dstInfo)
	if err != nil {
		return err
	}
	defer preparedArchive.Close()

	resolvedDstPath = dstDir
	content = preparedArchive

	options := types.CopyToContainerOptions{
		AllowOverwriteDirWithFile: true,
	}
	return d.client.CopyToContainer(ctx, container, resolvedDstPath, content, options)
}

func (d Docker) Start(ctx context.Context, container string) error {
	err := d.client.ContainerStart(ctx, container, types.ContainerStartOptions{})
	return err
}

func (d Docker) Stop(ctx context.Context, container string) error {
	timeout := time.Second * 5
	err := d.client.ContainerStop(ctx, container, &timeout)
	return err
}

func (d Docker) Rm(ctx context.Context, container string, force bool) error {
	err := d.client.ContainerRemove(ctx, container, types.ContainerRemoveOptions{Force: force})
	return err
}

func (d Docker) Push(ctx context.Context, image string, user string, password string) (string, error) {
	authConfig := types.AuthConfig{
		Username: user,
		Password: password,
	}
	encodedJSON, err := json.Marshal(authConfig)
	if err != nil {
		return "", err
	}

	authStr := base64.URLEncoding.EncodeToString(encodedJSON)
	reader, err := d.client.ImagePush(ctx, image, types.ImagePushOptions{RegistryAuth: authStr})
	if err != nil {
		return "", err
	}
	buf := new(bytes.Buffer)
	buf.ReadFrom(reader)
	return buf.String(), err
}

func (d Docker) Exec(ctx context.Context, container string, chdir string, cmd []string, env []string) (string, error) {
	id, err := d.client.ContainerExecCreate(ctx, container, types.ExecConfig{Tty: true, WorkingDir: chdir, Cmd: cmd, Env: env, AttachStderr: true, AttachStdout: true})
	if err != nil {
		return "", err
	}
	resp, err := d.client.ContainerExecAttach(ctx, id.ID, types.ExecStartCheck{})
	if err != nil {
		return "", err
	}
	buf := new(bytes.Buffer)
	buf.ReadFrom(resp.Reader)
	return buf.String(), err
}

func (d Docker) Restart(ctx context.Context, container string) error {
	_ = d.Stop(ctx, container)
	return d.Start(ctx, container)
}

func (d Docker) IsRun(ctx context.Context, container string) bool {
	stat, err := d.client.ContainerInspect(ctx, container)
	if err != nil {
		return false
	}
	if !stat.State.Running {
		return false
	}
	return true
}