Golang使用Docker client api接口

1. 首先安装docker

安装方法可参考官网： https://docs.docker.com/engine/install/centos/

docker version查看docker是否安装成功 

2. 如果是远程服务的Docker需要对外暴漏TCP端口（Docker 1.13.1版本）

         

 vim /usr/lib/systemd/system/docker.service    

 添加 -H tcp://0.0.0.0:12375 -H unix:///var/run/docker.sock \

 3. docker client接口的常用操作

go get github.com/docker/docker/client

package main

import (
	"context"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"os"
	"time"

	"github.com/docker/docker/api/types"
	"github.com/docker/docker/api/types/container"
	"github.com/docker/docker/client"
)

var (
	cli, err = client.NewClientWithOpts(client.WithHost("tcp://localhost:12375"))

	imageName     = "docker.io/busybox"
	containerID   = ""
	containerName = "busybox-test"
)

func main() {
	// imageList()
	// createContainer()
	// getContainers()

	// removeContainer()
	// containerLogs()

	// containerCommit()

	execContainer()
}

//拉取镜像
func pullImage() {
	ctx := context.Background()

	reader, err := cli.ImagePull(ctx, imageName, types.ImagePullOptions{})
	if err != nil {
		log.Fatal("pull image error", err)
	}

	io.Copy(os.Stdout, reader)
}

//拉取私有仓库的镜像
func pullPrivateImage() {
	ctx := context.Background()
	authConfig := types.AuthConfig{
		Username: "",
		Password: "",
	}
	encodeJson, _ := json.Marshal(authConfig)
	authStr := base64.StdEncoding.EncodeToString(encodeJson)
	out, err := cli.ImagePull(ctx, imageName, types.ImagePullOptions{RegistryAuth: authStr})
	if err != nil {
		log.Fatal("image pull error ", err.Error())
	}
	defer out.Close()
	io.Copy(os.Stdout, out)
}

//获取镜像列表
func imageList() {
	ctx := context.Background()
	images, err := cli.ImageList(ctx, types.ImageListOptions{All: true})
	if err != nil {
		log.Fatal(err)
	}

	list, _ := json.Marshal(images)
	fmt.Println(string(list))
	fmt.Println("image size:", len(images))
}

//创建容器
func createContainer() {
	ctx := context.Background()
	resp, err := cli.ContainerCreate(ctx, &container.Config{
		Image: imageName,
		Tty:   true,
		// Cmd:   []string{"/bin/bash"},
	}, nil, nil, nil, containerName)

	if err != nil {
		log.Fatal("create container error ", err.Error())
	}

	respBytes, _ := json.Marshal(resp)
	fmt.Println("create container response ", string(respBytes))

	err = cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{})
	if err != nil {
		log.Fatal("container start", err)
	}

	//wait running
	statusCh, errCh := cli.ContainerWait(ctx, resp.ID, container.WaitConditionNotRunning)
	select {
	case err := <-errCh:
		log.Fatal("container start error ", err.Error())
	case status := <-statusCh:
		fmt.Println("container start success ", status.StatusCode)
	}

	containerID = resp.ID

	//获取日志
	out, err := cli.ContainerLogs(ctx, resp.ID, types.ContainerLogsOptions{ShowStdout: true})
	if err != nil {
		log.Fatal("get container log error ", err.Error())
	}
	io.Copy(os.Stdout, out)
}

//获取正在运行的容器列表
func getContainers() {
	//All-true相当于docker ps -a
	containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{All: true})
	if err != nil {
		panic(err)
	}

	for _, container := range containers {
		fmt.Printf("%s %s\n", container.ID[:10], container.Image)
	}

	cbytes, _ := json.Marshal(containers)
	fmt.Println(string(cbytes))
}

//停止容器
func removeContainer() {
	ctx := context.Background()

	timeout := time.Minute
	err := cli.ContainerStop(ctx, containerID, &timeout)
	if err != nil {
		log.Fatal("stop container error ", err.Error())
	}
	fmt.Println("success")
}

//获取容器日志
func containerLogs() {
	ctx := context.Background()
	out, err := cli.ContainerLogs(ctx, containerID, types.ContainerLogsOptions{ShowStdout: true})
	if err != nil {
		log.Fatal("get container log error")
	}
	io.Copy(os.Stdout, out)
}

//保存容器成镜像
func containerCommit() {
	ctx := context.Background()

	commitResp, err := cli.ContainerCommit(ctx, containerID, types.ContainerCommitOptions{Reference: "helloworld"})
	if err != nil {
		log.Fatal(err)
	}

	b, _ := json.Marshal(commitResp)
	fmt.Println(string(b))

}

//进入容器
func execContainer() {
	ctx := context.Background()

	resp, err := cli.ContainerExecCreate(ctx, containerName, types.ExecConfig{
		Tty: true,
		Cmd: []string{"/sh"},
	})

	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(resp.ID)

}