在CSDN学Golang云原生（Docker容器）
一，Doker 命令行操作
在Go语言中，可以通过调用Docker命令行工具来进行容器管理和操作。下面是一些基本的Docker命令行操作示例：
- 启动一个新容器
cmd := exec.Command("docker", "run", "-d", "nginx")
if err := cmd.Run(); err != nil {
panic(err)
}这里使用了docker run命令来启动一个新的Nginx容器，并将其后台运行。
- 停止一个正在运行的容器
cmd := exec.Command("docker", "stop", "my-nginx-container")
if err := cmd.Run(); err != nil {
panic(err)
}这里使用了docker stop命令来停止名为“my-nginx-container”的容器。
- 删除一个已经停止的容器
cmd := exec.Command("docker", "rm", "my-nginx-container")
if err := cmd.Run(); err != nil {
panic(err)
}这里使用了docker rm命令来删除名为“my-nginx-container”的已停止容器。
- 构建一个新镜像
cmd := exec.Command("docker", "build", "-t", "my-custom-image:latest", ".")
if err := cmd.Run(); err != nil {
panic(err)
}这里使用了docker build命令从当前目录构建了一个名为“my-custom-image”的新镜像，并指定其标签为“latest”。
- 推送镜像到远程仓库
cmd := exec.Command("docker", "push", "my-registry.com/my-custom-image:latest")
if err := cmd.Run(); err != nil {
panic(err)
}这里使用了docker push命令将名为“my-custom-image”的镜像推送到名为“my-registry.com”的远程仓库中，并指定其标签为“latest”。
二，自定义容器启动命令或入口程序
在Go语言中，可以通过Docker API来自定义容器启动命令或入口程序。具体步骤如下：
- 安装Docker SDK for Go
要使用Docker API，首先需要安装docker/docker/client包。可以通过以下命令进行安装：
go get -u github.com/docker/[email protected]- 编写代码
接下来，可以编写代码来自定义容器启动命令或入口程序。以下是一个示例代码：
package main
import (
"context"
"fmt"
"github.com/docker/docker/api/types"
"github.com/docker/docker/client"
)
func main() {
// 创建一个新的客户端
ctx := context.Background()
cli, err := client.NewClientWithOpts(client.FromEnv)
if err != nil {
panic(err)
}
// 设置容器配置
config := &types.ContainerConfig{
Image: "nginx",
Cmd: []string{"nginx", "-g", "daemon off;"},
ExposedPorts: map[nat.Port]struct{}{
nat.Port("80/tcp"): {},
},
}
// 创建并启动容器
resp, err := cli.ContainerCreate(ctx, config, nil, nil, "")
if err != nil {
panic(err)
}
if err = cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
panic(err)
}
fmt.Println(resp.ID)
}在上面的示例中，我们使用了client.NewClientWithOpts(client.FromEnv)方法创建了一个新的Docker客户端，并设置了容器配置。在这里，我们将容器的镜像设置为Nginx，并指定了自定义的启动命令["nginx", "-g", "daemon off;"]。我们还将80端口映射到了宿主机上。
最后，我们使用cli.ContainerCreate()方法创建并启动了一个新的容器，并打印了其ID。
- 运行代码
运行以上代码后，可以看到输出结果中包含有新创建的容器ID。
需要注意的是，在使用Docker API时需要具有足够的权限。如果没有正确的权限，可能会遇到一些问题。同时，在编写代码时应该注意安全性和可靠性等方面的问题。
三，容器health check
在 Go 语言中，我们可以使用 github.com/docker/docker/client 包来创建和管理 Docker 容器，并设置容器的健康检查。下面是一个示例代码，展示如何使用容器健康检查：
package main
import (
"context"
"fmt"
"time"
"github.com/docker/docker/api/types"
"github.com/docker/docker/api/types/container"
"github.com/docker/docker/api/types/strslice"
"github.com/docker/docker/client"
)
func main() {
ctx := context.Background()
cli, err := client.NewClientWithOpts(client.FromEnv)
if err != nil {
panic(err)
}
containerConfig := &container.Config{
Image: "nginx",
AttachStdout: true,
AttachStderr: true,
Tty: true,
Healthcheck: &container.HealthConfig{
Test: strslice.StrSlice{"/usr/bin/curl", "-f", "http://localhost"},
Interval: time.Duration(10) * time.Second,
Timeout: time.Duration(5) * time.Second,
StartPeriod: time.Duration(0) * time.Second,
Retries: 3,
},
}
hostConfig := &container.HostConfig{}
resp, err := cli.ContainerCreate(ctx, containerConfig, hostConfig, nil, "")
if err != nil {
panic(err)
}
fmt.Println("Container ID:", resp.ID)
err = cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{})
if err != nil {
panic(err)
}
statusCh, errCh := cli.ContainerWait(ctx, resp.ID, container.WaitConditionNotRunning)
select {
case err := <-errCh:
if err != nil {
panic(err)
}
case status := <-statusCh:
fmt.Println("Container exited with status:", status.StatusCode)
}
}上面的示例中，我们使用 container.HealthConfig 结构体来定义容器的健康检查配置。通过设置 Test 字段，我们可以指定一个命令或脚本来测试容器的健康状态。在这个例子中，我们使用 /usr/bin/curl -f http://localhost 命令来测试容器是否能够访问本地主机。
除了 Test 字段之外，还有其他几个字段可以用于调整健康检查的行为：
Interval: 容器健康检查的间隔时间。Timeout: 每次健康检查的超时时间。StartPeriod: 在容器启动后多少秒开始进行第一次健康检查。Retries: 当连续失败几次后认为容器不可用。
设置完容器的健康检查配置后，我们可以使用 cli.ContainerCreate 函数创建容器，并在其中包含配置信息。然后使用 cli.ContainerStart 函数启动容器，并使用 cli.ContainerWait 函数等待容器退出并返回状态信息。
需要注意的是，在运行具有长期运行服务（例如 Web 服务器）的 Docker 容器时，请务必确保正确设置健康检查和自动重启策略以确保高可用性。
四，容器重启策略
在 Go 语言中，可以使用 Docker API 来为容器设置重启策略。以下是一个示例代码：
package main
import (
"context"
"fmt"
"github.com/docker/docker/api/types"
"github.com/docker/docker/client"
)
func main() {
ctx := context.Background()
cli, err := client.NewClientWithOpts(client.FromEnv)
if err != nil {
panic(err)
}
containerConfig := &types.ContainerConfig{
Image: "nginx",
Cmd: []string{"nginx", "-g", "daemon off;"},
}
hostConfig := &types.HostConfig{
// 设置重启策略
RestartPolicy: types.RestartPolicy{
Name: "on-failure",
MaximumRetryCount: 3,
},
}
resp, err := cli.ContainerCreate(ctx, containerConfig, hostConfig, nil, "")
if err != nil {
panic(err)
}
if err = cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
panic(err)
}
fmt.Println(resp.ID)
}在上面的示例中，我们通过 types.RestartPolicy 结构体设置了重启策略。具体来说，我们定义了一个 Name 字段，在其中指定了容器停止时应该采取的操作。这里我们选择的是“on-failure”，即只有在容器退出时才会自动重启。另外，我们还设置了最大重试次数。
需要注意的是，在使用 Docker API 时需要具有足够的权限。如果没有正确的权限，可能会遇到一些问题。同时，在编写代码时应该注意安全性和可靠性等方面的问题。
五，容器资源配额
在 Go 语言中，我们可以使用 Docker API 来设置容器的资源配额。以下是一个示例代码：
package main
import (
"context"
"fmt"
"github.com/docker/docker/api/types"
"github.com/docker/docker/api/types/container"
"github.com/docker/docker/client"
)
func main() {
ctx := context.Background()
cli, err := client.NewClientWithOpts(client.FromEnv)
if err != nil {
panic(err)
}
containerConfig := &container.Config{
Image: "nginx",
}
hostConfig := &container.HostConfig{
// 设置 CPU 配额
CpuQuota: int64(100000),
// 设置内存限制
Memory: int64(536870912),
}
resp, err := cli.ContainerCreate(ctx, containerConfig, hostConfig, nil, "")
if err != nil {
panic(err)
}
if err = cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
panic(err)
}
inspectResp, _ ,err := cli.ContainerInspectWithRaw(ctx, resp.ID)
if err != nil {
panic(err)
}
fmt.Println("cpu quota:", inspectResp.HostConfig.Resources.CPUQuota)
fmt.Println("memory limit:", inspectResp.HostConfig.Resources.Memory)
}在上面的示例中，我们通过 HostConfig 结构体来定义了容器的资源配额。其中，CpuQuota 字段表示 CPU 配额，单位为微秒（1/1000 毫秒），而 Memory 字段则表示内存限制，单位为字节。
在实际应用中，我们可以根据需要设置不同的资源配额以满足业务需求。值得注意的是，在使用资源配额功能时要确保目标容器支持该功能，并且正确配置监控参数才能够发挥最大效益。
六，容器命名空间隔离
在 Go 语言中，我们可以使用 github.com/docker/docker/client 包来创建和管理 Docker 容器。下面是一个示例代码，展示如何通过命名空间隔离来创建一个新的容器：
package main
import (
"context"
"fmt"
"github.com/docker/docker/api/types"
"github.com/docker/docker/api/types/container"
"github.com/docker/docker/client"
)
func main() {
ctx := context.Background()
cli, err := client.NewClientWithOpts(client.FromEnv)
if err != nil {
panic(err)
}
// 创建命名空间隔离的网络
networkCreateResp, err := cli.NetworkCreate(ctx, "my-network", types.NetworkCreate{})
if err != nil {
panic(err)
}
// 定义容器配置
containerConfig := &container.Config{
Image: "nginx",
AttachStdout: true,
AttachStderr: true,
Tty: true,
}
// 定义主机配置
hostConfig := &container.HostConfig{
NetworkMode: container.NetworkMode(networkCreateResp.ID),
}
resp, err := cli.ContainerCreate(ctx, containerConfig, hostConfig, nil, "")
if err != nil {
panic(err)
}
err = cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{})
if err != nil {
panic(err)
}
fmt.Println("Container ID:", resp.ID)
}上面的示例中，我们通过 networkCreateResp 变量创建了一个名为 my-network 的网络，并将其绑定到新建的容器中。在定义主机配置时，我们将容器与该网络进行了绑定。通过这种方式，容器就可以在一个独立的命名空间内运行，与主机和其他容器隔离开来。
值得注意的是，在创建命名空间隔离的网络时，需要确保该网络的名称在宿主机上是唯一的。否则会出现名称冲突导致创建失败的情况。同时，我们也要确保目标容器所需的所有网络资源都被正确配置才能够正常使用。
七，Volume数据存储持久化与数据共享
在 Go 语言中，我们可以使用 github.com/docker/docker/client 包来创建和管理 Docker 容器，并通过挂载数据卷的方式实现数据存储持久化和共享。下面是一个示例代码，展示如何使用数据卷来创建一个新的容器：
package main
import (
"context"
"fmt"
"github.com/docker/docker/api/types"
"github.com/docker/docker/api/types/container"
"github.com/docker/docker/client"
)
func main() {
ctx := context.Background()
cli, err := client.NewClientWithOpts(client.FromEnv)
if err != nil {
panic(err)
}
hostConfig := &container.HostConfig{
Binds: []string{"/path/on/host:/path/on/container"},
}
containerConfig := &container.Config{
Image: "nginx",
AttachStdout: true,
AttachStderr: true,
Tty: true,
}
resp, err := cli.ContainerCreate(ctx, containerConfig, hostConfig, nil, "")
if err != nil {
panic(err)
}
err = cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{})
if err != nil {
panic(err)
}
fmt.Println("Container ID:", resp.ID)
}上面的示例中，我们通过将 /path/on/host 目录与 /path/on/container 目录进行绑定，从而实现了主机和容器之间的数据共享。这样，在容器内部修改 /path/on/container 目录下的文件时，就会直接影响到主机上对应目录下的文件。
如果想要实现数据存储持久化，可以将数据卷挂载到一个宿主机目录上，并通过 -v 参数指定挂载方式。例如：
hostConfig := &container.HostConfig{
Binds: []string{"/path/on/host:/path/on/container"},
}其中 /path/on/host 表示宿主机上的目录，/path/on/container 表示容器内部的目录。
在实际使用中，我们还可以通过 docker volume create 命令创建一个数据卷，并通过 -v 参数指定其名称和挂载方式。例如：
hostConfig := &container.HostConfig{
Binds: []string{"my-volume:/path/on/container"},
}
_, err = cli.VolumeCreate(ctx, types.VolumeCreateBody{Name: "my-volume"})
if err != nil {
panic(err)
}这样，在容器启动时就会自动挂载名为 my-volume 的数据卷，从而实现数据存储持久化和共享。
八，bridge，host，overlay网络驱动
在 Go 语言中，我们可以使用 github.com/docker/docker/client 包来创建和管理 Docker 容器，并通过不同类型的网络驱动来实现容器之间的通信。下面是一个示例代码，展示如何使用 bridge、host 和 overlay 网络驱动来创建不同类型的网络：
package main
import (
"context"
"fmt"
"github.com/docker/docker/api/types"
"github.com/docker/docker/api/types/container"
"github.com/docker/docker/api/types/network"
"github.com/docker/docker/client"
)
func main() {
ctx := context.Background()
cli, err := client.NewClientWithOpts(client.FromEnv)
if err != nil {
panic(err)
}
// 创建 bridge 网络
netConfig := &network.NetworkingConfig{
EndpointsConfig: map[string]*network.EndpointSettings{
"my-bridge": &network.EndpointSettings{},
},
}
resp, err := cli.NetworkCreate(ctx, "my-bridge", types.NetworkCreate{Driver: "bridge", CheckDuplicate: true})
if err != nil {
panic(err)
}
fmt.Println("Bridge network ID:", resp.ID)
containerConfig := &container.Config{
Image: "nginx",
AttachStdout: true,
AttachStderr: true,
Tty: true,
}
hostConfig := &container.HostConfig{}
networkingConfig := &network.NetworkingConfig{
EndpointsConfig: map[string]*network.EndpointSettings{
"my-bridge": &network.EndpointSettings{},
},
}
// 创建容器并加入 bridge 网络
resp, err = cli.ContainerCreate(ctx, containerConfig, hostConfig, networkingConfig, "")
if err != nil {
panic(err)
}
err = cli.NetworkConnect(ctx, "my-bridge", resp.ID, &network.EndpointSettings{})
if err != nil {
panic(err)
}
fmt.Println("Container ID:", resp.ID)
// 创建 host 网络
resp, err = cli.NetworkCreate(ctx, "my-host", types.NetworkCreate{Driver: "host", CheckDuplicate: true})
if err != nil {
panic(err)
}
fmt.Println("Host network ID:", resp.ID)
// 创建 overlay 网络
resp, err = cli.NetworkCreate(ctx, "my-overlay", types.NetworkCreate{
Driver: "overlay",
CheckDuplicate: true,
IPAM: &network.IPAM{},
})
if err != nil {
panic(err)
}
fmt.Println("Overlay network ID:", resp.ID)
}上面的示例中，我们使用 cli.NetworkCreate 函数创建了三种不同类型的网络：bridge、host 和 overlay。对于每种网络类型，我们都需要指定相应的驱动和配置信息。
在创建容器时，我们可以通过 networkingConfig 参数将容器加入特定的网络中。例如，在创建 bridge 网络时，我们可以将容器加入名为 my-bridge 的网络：
networkingConfig := &network.NetworkingConfig{
EndpointsConfig: map[string]*network.EndpointSettings{
"my-bridge": &network.EndpointSettings{},
},
}
resp, err = cli.ContainerCreate(ctx, containerConfig, hostConfig, networkingConfig, "")
if err != nil {
panic(err)
}
err = cli.NetworkConnect(ctx, "my-bridge", resp.ID, &network.EndpointSettings{})
if err != nil {
panic(err)
}类似地，我们可以使用 cli.NetworkConnect 函数将容器加入其他类型的网络中。
需要注意的是，在创建 overlay 网络时，我们需要指定一个 IPAM 配置来管理容器的 IP 地址分配。如果不指定 IPAM 配置，容器就无法在 overlay 网络中通信。