【Golang】golang使用三方SDK操作容器指南

news2024/9/22 23:23:55

【Golang】golang使用三方SDK操作容器指南

大家好 我是寸铁👊
总结了一篇 golang使用三方SDK操作容器✨
喜欢的小伙伴可以点点关注 💝
这应该是目前全网最全golang使用三方SDK操作容器的指南了✌️

CreateConfig

主要是创建容器的配置信息，常用的字段

使用包如下：

"github.com/docker/docker/api/types"

配置创建Docker 容器的结构体，具体字段的含义和用途如下：

1.Hostname: 容器的主机名。

2.Domainname: 容器的域名。

3.User: 执行容器内命令的用户，也支持指定用户和用户组。

4.AttachStdin: 是否连接标准输入，使得用户可以与容器进行交互。

5.AttachStdout: 是否连接标准输出。

6.AttachStderr: 是否连接标准错误输出。

7.ExposedPorts: 用于指定容器暴露的端口，是一个 nat.PortSet 类型的字段。

8.Tty: 是否将标准流连接到 tty（终端），包括标准输入（如果它没有关闭的话）。

9.OpenStdin: 是否打开标准输入。

10.StdinOnce: 如果为 true，在第一个连接的客户端断开连接后关闭标准输入。

11.Env: 设置在容器中使用的环境变量的列表。

12.Cmd: 在启动容器时运行的命令。

13.Healthcheck: 描述容器健康状况检查的配置。

14.ArgsEscaped: 如果为 true，表示命令已经被转义，即将其视为命令行（特定于 Windows）。

15.Image: 由操作者传递的镜像的名称。

16.Volumes: 用于指定容器使用的卷（挂载）的列表。

17.WorkingDir: 容器中命令执行的当前目录（PWD）。

18.Entrypoint: 在启动容器时运行的入口点。

19.NetworkDisabled: 是否禁用网络。

20.MacAddress: 容器的 MAC 地址。注意，此字段在 API 版本 v1.44 后已被废弃，建议使用 EndpointSettings.MacAddress 替代。

21.OnBuild：在 Dockerfile 中定义的 ONBUILD 元数据。这个字段用于保存在构建镜像时定义的 ONBUILD 指令，它们将在基础镜像的构建过程中执行。

22.Labels：容器的标签列表。这个字段是一个映射，用于存储容器的元数据信息，如作者、版本、描述等。标签可以用于组织和识别容器，也可以用于进行元数据查询。

23.StopSignal：停止容器时发送的信号。这个字段指定了停止容器时使用的信号，例如 SIGTERM 或 SIGKILL。

24.StopTimeout：停止容器的超时时间（以秒为单位）。这个字段指定了在发送停止信号后等待容器停止的时间。如果容器在超时时间内未停止，则强制终止。

25.Shell：用于 shell 形式的 RUN、CMD、ENTRYPOINT 的 shell。这个字段指定了容器内部使用的 shell 解释器，用于执行 Dockerfile 中的命令。omitempty 表示如果字段为空，则在 JSON 输出中省略该字段。

基本操作demo

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() {
	// 初始化 Docker 客户端
	cli, err := client.NewClientWithOpts(client.FromEnv)
	if err != nil {
		panic(err)
	}

	//创建容器的配置信息
	createConfig := &container.Config{
		Image: "your_image_name",
		// 可以根据需要配置其他容器参数
	}

	//停止容器的配置信息
	stopConfig := container.StopOptions{}

	//删除容器的配置信息
	removeOptions := types.ContainerRemoveOptions{
		RemoveVolumes: true, // 删除容器关联的卷
		Force:         true, // 强制删除容器
	}

	// 列出所有容器的列表
	containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{})
	if err != nil {
		panic(err)
	}

	//操作每个容器的信息和容器的各种操作
	for _, dockerContainer := range containers {
		fmt.Printf("容器 ID：%s\n", dockerContainer.ID)
		fmt.Printf("容器 名称：%s\n", dockerContainer.Names)

		// 在这里可以添加逻辑来判断特定条件下的容器，并对其进行操作
		// 例如，暂停、删除等操作

		//容器的创建
		//使用容器的名字创建容器,配置文件配置镜像等等信息。
		//创建容器的时候返回创建的容器ID
		createID, err := cli.ContainerCreate(context.Background(), createConfig, nil, nil, nil, "my-container-18")
		if err != nil {
			panic(err)
		}
		fmt.Println("创建的容器ID为: ", createID)

		//容器的删除
		err = cli.ContainerRemove(context.Background(), dockerContainer.ID, removeOptions)
		if err != nil {
			panic(err)
		}

		//容器的暂停
		err = cli.ContainerPause(context.Background(), dockerContainer.ID)
		if err != nil {
			panic(err)
		}

		//容器的恢复
		err = cli.ContainerUnpause(context.Background(), dockerContainer.ID)
		if err != nil {
			panic(err)
		}

		//容器的停止
		err = cli.ContainerStop(context.Background(), dockerContainer.ID, stopConfig)
		if err != nil {
			panic(err)
		}

		//容器的重启
		err = cli.ContainerRestart(context.Background(), dockerContainer.ID, stopConfig)
		if err != nil {
			panic(err)
		}
	}
}

查找容器信息

cmd

对应于cmd的命令如下：

docker ps

类似于cmd的方式，这里可以使用golang程序拿到如下字段信息，查出当前运行的所有容器的信息。

在这里插入图片描述

实例

package main

import (
	"context"
	"fmt"
	"github.com/docker/docker/api/types"
	"github.com/docker/docker/client"
)

/*
需求：
尝试在golang中拉取镜像、创建容器、删除容器、停止容器、暂停容器、恢复容器、重启容器。
运行容器、怎么使用docker run去运行一个容器、怎么使用docer build命令
看看其他在docker-cli中执行的命令是否使用go程序也能够正常执行。
*/

func main() {
	// 初始化 Docker 客户端
	cli, err := client.NewClientWithOpts(client.FromEnv)
	if err != nil {
		panic(err)
	}
	// 先得到列出所有容器的列表
	containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{})
	if err != nil {
		panic(err)
	}

	// 对应为docker ps -a 命令
	// 再从列表中拿到信息
	for _, container := range containers {
		fmt.Printf("CONTAINER ID: %s\n", container.ID)
		fmt.Printf("IMAGE: %s \n", container.Image)
		fmt.Printf("COMMAND: %s \n", container.Command)
		fmt.Printf("CREATED: %s \n", container.Created)
		fmt.Printf("Status: %s \n", container.Status)
		fmt.Printf("PORTS: %s \n", container.Ports)
		fmt.Printf("NAMES：%s\n", container.Names)
	}
}

运行结果

遍历容器，拿到容器的各种字段信息，与docker ps 命令的信息一致。

在这里插入图片描述

创建容器

cmd

运行容器，一般是指定容器内的端口和容器的名字(不能与之前的名字重复)

--expose:编辑容器内的端口

--name:编辑容器的名字

最后的my-golang-app 为镜像源

docker run --expose 3888/tcp --name mycontainer-15 my-golang-app

结果如下：

在这里插入图片描述

实例

package main

import (
	"context"
	"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"
	"github.com/docker/go-connections/nat"
	"io"
	"log"
	"os"
)

func main() {
	ctx := context.Background()
	cli, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
	if err != nil {
		log.Fatal(err)
	}

    //配置容器的各种信息,如镜像源、容器内的端口
	containerConfig := &container.Config{
		Image: "my-golang-app",
		ExposedPorts: nat.PortSet{
			"3889/tcp": {},
		},
	}

	hostConfig := &container.HostConfig{}

	networkingConfig := &network.NetworkingConfig{}

	//创建容器
	resp, err := cli.ContainerCreate(ctx, containerConfig, hostConfig, networkingConfig, nil, "mycontainer-20")
	if err != nil {
		log.Fatal(err)
	}

	//启动容器
	if err := cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
		log.Fatal(err)
	}
    //容器在后台运行
    //fmt.Println("容器ID为: " , resp.ID)
	
    // 获取容器的日志
	out, err := cli.ContainerLogs(ctx, resp.ID, types.ContainerLogsOptions{ShowStdout: true, ShowStderr: true})
	if err != nil {
		log.Fatal(err)
	}
	defer out.Close()

	// 打印容器的日志到控制台
	go func() {
		_, err := io.Copy(os.Stdout, out)
		if err != nil && err != io.EOF {
			log.Fatal(err)
		}
	}()

	// 等待容器运行完成
	statusCh, errCh := cli.ContainerWait(ctx, resp.ID, container.WaitConditionNotRunning)
	for {
		select {
		case err := <-errCh:
			if err != nil {
				log.Fatal(err)
			}
		case <-statusCh:
			return
		default:
			// 如果没有接收到任何数据，则继续等待
		}
	}
}

运行结果

查看创建的容器的基本信息，如容器的端口和名字等等。

对照一下，两种方式创建的结果都是一样的。

在这里插入图片描述

程序中使用日志的方式打印出使用dockerfile的go程序运行的结果，但是打印一个数字后被阻塞了。

在这里插入图片描述

如果不使用上面程序的日志输出，运行时是以后台的方式运行的，也就不会直接把程序运行的结果输出来。可以先创建，再使用Attach方法进入容器，就可以输出程序的内容了。具体见下面进入容器部分。

删除容器

cmd

docker rm -f 容器ID

查看结果如下:

在这里插入图片描述

实例

package main

import (
	"context"
	"fmt"

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

func main() {
	// 创建 Docker 客户端
	cli, err := client.NewEnvClient()
	if err != nil {
		panic(err)
	}

	// 定义要删除的容器 ID
	containerID := "d815a35c7822"

	// 定义删除容器时的选项
	options := types.ContainerRemoveOptions{
		Force:         true,  // 强制删除容器
		RemoveVolumes: true,  // 删除关联的数据卷
		RemoveLinks:   false, // 不删除关联的链接
	}

	// 调用 ContainerRemove 方法删除容器
	err = cli.ContainerRemove(context.Background(), containerID, options)
	if err != nil {
		fmt.Printf("Failed to remove container: %v\n", err)
	} else {
		fmt.Println("Container removed successfully")
	}
}

运行结果

程序运行结果如下:

在这里插入图片描述

删除容器13之前

在这里插入图片描述

容器13成功删除了

在这里插入图片描述

停止容器

cmd

docker stop 容器ID

停止容器前，状态为Up。

在这里插入图片描述

停止容器后，状态为Exited。

在这里插入图片描述

实例

package main

import (
	"context"
	"fmt"
	"github.com/docker/docker/api/types/container"

	"github.com/docker/docker/client"
)

func main() {
	// 创建 Docker 客户端
	cli, err := client.NewEnvClient()
	if err != nil {
		panic(err)
	}

	// 定义要停止的容器 ID
	containerID := "b50423e8aade"

	stopOptions := container.StopOptions{}

	// 调用 ContainerStop 方法停止容器
	err = cli.ContainerStop(context.Background(), containerID, stopOptions)
	if err != nil {
		fmt.Printf("Failed to stop container: %v\n", err)
	} else {
		fmt.Println("Container stopped successfully")
	}
}

运行结果

程序执行结果如下：

在这里插入图片描述

检查是否停止成功如下：

停止前

在这里插入图片描述

停止后

在这里插入图片描述

程序执行结果与cmd停止命令一致。

重启容器

cmd

docker restart 9ef8ae3b59d9

容器已停止：

在这里插入图片描述

重启容器：

在这里插入图片描述

重启容器后，容器的状态如下：

在这里插入图片描述

实例

package main

import (
	"context"
	"fmt"
	"github.com/docker/docker/api/types/container"

	"github.com/docker/docker/client"
)

func main() {
	// 创建 Docker 客户端
	cli, err := client.NewEnvClient()
	if err != nil {
		panic(err)
	}

	// 定义要重启的容器 ID
	containerID := "746a98dfb20c"

	topOptions := container.StopOptions{}

	// 调用 ContainerRestart 方法重启容器
	err = cli.ContainerRestart(context.Background(), containerID, topOptions)
	if err != nil {
		panic(err)
	}

	fmt.Printf("Container %s has been restarted.\n", containerID)
}

运行结果

重启前：

在这里插入图片描述

重启后：

在这里插入图片描述

运行结果如下：

在这里插入图片描述

重启完成，和cmd的执行结果一致。

暂停容器

cmd

docker pause 容器ID

暂停容器前

在这里插入图片描述

暂停容器后

在这里插入图片描述

实例

package main

import (
	"context"
	"fmt"
	"github.com/docker/docker/client"
)

func main() {
	// 创建 Docker 客户端
	cli, err := client.NewEnvClient()
	if err != nil {
		panic(err)
	}

	// 定义要暂停的容器 ID
	containerID := "e4d6650df3af"

	// 暂停容器
	err = cli.ContainerPause(context.Background(), containerID)
	if err != nil {
		fmt.Printf("Failed to pause container: %v\n", err)
	} else {
		fmt.Println("Container paused successfully")
	}
}

运行结果

暂停容器前:

在这里插入图片描述

暂停容器:

在这里插入图片描述

运行结果如下:

在这里插入图片描述

恢复暂停

cmd

docker unpause 容器ID

恢复暂停前：

在这里插入图片描述

恢复暂停成功：

在这里插入图片描述

实例

package main

import (
	"context"
	"fmt"
	"github.com/docker/docker/client"
)

func main() {
	// 创建 Docker 客户端
	cli, err := client.NewEnvClient()
	if err != nil {
		panic(err)
	}

	// 定义要暂停的容器 ID
	containerID := "e4d6650df3af"

	// 暂停容器
	err = cli.ContainerPause(context.Background(), containerID)
	if err != nil {
		fmt.Printf("Failed to pause container: %v\n", err)
	} else {
		fmt.Println("Container paused successfully")
	}
}

运行结果

恢复前：

在这里插入图片描述

恢复暂停：

在这里插入图片描述

运行结果如下：

在这里插入图片描述

说明确实是恢复暂停成功了！

进入容器

Attach

cmd
docker attach 容器ID

运行结果如下：

在这里插入图片描述

退出容器，发现容器也停止掉了。

在这里插入图片描述

注意: 这种进入容器的方式使用exit退出会把整个容器都停止掉。但是使用go的程序停止却不会使得容器停止。

实例

要进入容器，可以使用 Docker 客户端的 ContainerAttach 方法。这个方法允许您连接到容器的标准输入、输出和错误流，并与容器进行交互。

package main

import (
	"context"
	"fmt"
	"io"
	"os"

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

func main() {
	// 创建 Docker 客户端
	cli, err := client.NewEnvClient()
	if err != nil {
		panic(err)
	}

	// 定义要进入的容器 ID
	containerID := "e4d6650df3af"

	// 定义进入容器时的选项
	options := types.ContainerAttachOptions{
		Stream: true,
		Stdin:  true,
		Stdout: true,
		Stderr: true,
	}

	// 调用 ContainerAttach 方法进入容器
	resp, err := cli.ContainerAttach(context.Background(), containerID, options)
	if err != nil {
		panic(err)
	}
	defer resp.Close()

	// 将容器的标准输入输出连接到当前进程的标准输入输出
	go io.Copy(os.Stdout, resp.Reader)
	go io.Copy(resp.Conn, os.Stdin)

	// 等待用户输入以继续运行
	fmt.Println("Press enter to exit...")
	fmt.Scanln()
}
运行结果

运行结果如下:

在这里插入图片描述

退出程序：

在这里插入图片描述

退出程序但是不会停止掉程序：

在这里插入图片描述

ExecAttach

cmd
docker exec -it mycontainer-18 bash

这样的进入容器是以命令行的方式进入容器的，所以不会输出程序的运行结果，但是使用exit退出程序不会关闭程序。

退出程序：

在这里插入图片描述

使用exit退出程序，发现确实是没有关闭程序。

在这里插入图片描述

实例
package main

import (
	"context"
	"fmt"
	"io"
	"os"

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

func main() {
	// 创建 Docker 客户端
	cli, err := client.NewEnvClient()
	if err != nil {
		panic(err)
	}

	// 定义要进入的容器 ID
	containerID := "e4d6650df3af"

	// 定义要执行的命令
	cmd := []string{"sh"} // 这里可以根据需要修改为其他交互式 shell，如 bash

	// 准备执行命令的选项
	createResp, err := cli.ContainerExecCreate(context.Background(), containerID, types.ExecConfig{
		Cmd:          cmd,
		AttachStdin:  true,
		AttachStdout: true,
		AttachStderr: true,
		Tty:          true,
	})
	if err != nil {
		panic(err)
	}

	// 连接到正在运行的命令以进行交互
	resp, err := cli.ContainerExecAttach(context.Background(), createResp.ID, types.ExecStartCheck{
		Tty: true,
	})
	if err != nil {
		panic(err)
	}
	defer resp.Close()

	// 将容器的标准输入输出连接到当前进程的标准输入输出
	go func() {
		if _, err := io.Copy(os.Stdout, resp.Reader); err != nil {
			panic(err)
		}
	}()

	go func() {
		if _, err := io.Copy(resp.Conn, os.Stdin); err != nil {
			panic(err)
		}
	}()

	// 等待用户输入以继续运行
	fmt.Println("Press enter to exit...")
	fmt.Scanln()
}
运行结果

以命令行的方式进入容器进行交互，和直接使用cmd的方式是一样的。

在这里插入图片描述

小结

以上两种方式都可以进入容器，需要结合具体使用场景进行权衡。

  • 其中一个是可以看到程序的执行结果，但是退出会直接关闭掉容器。
  • 另一个是以命令行的方式进入容器进行交互，退出不会直接关闭容器。

拉取镜像

cmd

对应到cmd命令如下：

docker pull 镜像名

如下：

docker pull nginx:latest

拉取结果如下：

在这里插入图片描述

实例

package main

import (
	"context"
	"encoding/json"
	"fmt"

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

func main() {
	// 创建 Docker 客户端
	cli, err := client.NewEnvClient()
	if err != nil {
		panic(err)
	}

	// 定义要拉取的镜像的名称和标签
	imageName := "redis"
	imageTag := "latest"
	imageRef := imageName + ":" + imageTag

	// 拉取镜像
	out, err := cli.ImagePull(context.Background(), imageRef, types.ImagePullOptions{})
	if err != nil {
		panic(err)
	}
	defer out.Close()

	// 解析拉取镜像的输出
	var pullResponse struct {
		Status string `json:"status"`
	}
	if err := json.NewDecoder(out).Decode(&pullResponse); err != nil {
		panic(err)
	}

	fmt.Printf("Pulling image %s: %s\n", imageRef, pullResponse.Status)
}

运行结果

拉取镜像成功，和cmd拉取镜像的方式一致。

在这里插入图片描述

拉取镜像

cmd

对应到cmd命令如下：

docker pull 镜像名

如下：

docker pull nginx:latest

拉取结果如下：

[外链图片转存中...(img-XuptRPZC-1709983420532)]

实例

package main

import (
	"context"
	"encoding/json"
	"fmt"

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

func main() {
	// 创建 Docker 客户端
	cli, err := client.NewEnvClient()
	if err != nil {
		panic(err)
	}

	// 定义要拉取的镜像的名称和标签
	imageName := "redis"
	imageTag := "latest"
	imageRef := imageName + ":" + imageTag

	// 拉取镜像
	out, err := cli.ImagePull(context.Background(), imageRef, types.ImagePullOptions{})
	if err != nil {
		panic(err)
	}
	defer out.Close()

	// 解析拉取镜像的输出
	var pullResponse struct {
		Status string `json:"status"`
	}
	if err := json.NewDecoder(out).Decode(&pullResponse); err != nil {
		panic(err)
	}

	fmt.Printf("Pulling image %s: %s\n", imageRef, pullResponse.Status)
}

运行结果

拉取镜像成功，和cmd拉取镜像的方式一致。

[外链图片转存中...(img-2KfAupd8-1709983420532)]

更新容器

应用场景

  1. 动态调整资源限制： 您可能希望根据应用程序的负载情况动态调整容器的资源限制，例如内存限制、CPU 配额等。通过更新容器配置，您可以在不停止容器的情况下调整这些限制，从而使容器能够适应不同的负载。
  2. 修改网络配置： 在某些情况下，您可能需要修改容器的网络配置，例如更改容器的端口映射、连接到不同的网络或修改容器的主机名等。通过更新容器配置，您可以实现这些网络配置的变更，而无需重新创建容器。
  3. 更新挂载卷： 如果您使用了挂载卷来与容器共享数据或配置文件，可能会需要在运行时更新挂载卷的配置。通过更新容器配置，您可以修改容器挂载的卷，例如更改卷的路径或添加新的挂载卷。
  4. 应用配置更改： 在某些情况下，您可能需要更新容器中运行的应用程序的配置。通过更新容器配置，您可以传递新的环境变量、更新容器的命令或参数等，从而修改容器中应用程序的配置。

总的来说，ContainerUpdate 方法可以用于在容器运行时对其进行动态配置更改，而不需要停止和重新启动容器。这种能力使得容器的管理更加灵活，并能够在不中断服务的情况下进行必要的调整和更新。

cmd

docker update命令用于更新一个正在运行的容器的配置。它允许你修改容器的资源限制、重启策略和其他配置选项。以下是docker update命令的基本用法：

docker update 容器id/名字

实例

cli.ContainerUpdate 更新容器的资源限制、重启策略和其他配置选项，并不是更新容器的镜像、端口之类的配置。其他暂无直接更新的API。

采用：先删除原有容器，再根据配置信息进行重建的封装函数。不过，这么做需要会影响容器内正在运行的服务，需要考虑一下。

更新的结构体如下：

updateConfig := container.UpdateConfig{
		Resources: container.Resources{
			Memory:   512000000,  // 设置内存限制为 512MB
			NanoCPUs: 1000000000, // 设置 CPU 配额（以纳秒为单位）
		},
	}

端口和挂载卷配置示例：

// 容器端口映射，键为容器端口，值为宿主机端口
	portMapping := map[string]string{
		"80/tcp": "8080",
	}

	// 容器挂载卷
	volumeMounts := []mount.Mount{
		{
			Type:   mount.TypeBind,
			Source: "/host/path", // 宿主机路径
			Target: "/container/path", // 容器路径
		},
	}

demo

package main

import (
	"context"
	"fmt"
	"log"

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

func main() {
	// 创建 Docker 客户端
	cli, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
	if err != nil {
		log.Fatal(err)
	}

	// 容器ID，需要根据实际情况修改
	containerID := "your_container_id_here"

	// 配置更新
	updateConfig := container.UpdateConfig{
		Resources: container.Resources{
			Memory:   512000000,  // 设置内存限制为 512MB
			NanoCPUs: 1000000000, // 设置 CPU 配额（以纳秒为单位）
		},
	}

	// 执行容器更新
	err = updateContainer(cli, containerID, updateConfig)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println("容器配置已更新")
}

// updateContainer 函数用于更新容器的配置信息
func updateContainer(cli *client.Client, containerID string, updateConfig container.UpdateConfig) error {
	ctx := context.Background()

	// 执行容器更新
	_, err := cli.ContainerUpdate(ctx, containerID, updateConfig)
	if err != nil {
		return err
	}

	return nil
}

运行结果

更新容器的内存资源限制(单位bytes)

运行结果如下：

在这里插入图片描述

补充

还了解到一个方法：cli.ConfigUpdate() ，不过这个更新不是更新容器信息的，可更新的配置信息也非常少，基本与容器无关。

后面了解到，其实它主要用于更新 Docker Swarm 配置的信息。

在 Docker 中，Swarm 是 Docker 官方提供的用于容器编排和集群管理的工具。Swarm 允许您将多个 Docker 主机组合成一个虚拟的、单一的 Docker 主机。Swarm 中有许多配置项可以控制集群的行为，例如服务配置、网络配置、秘密配置等。

方法体如下：

// ConfigUpdate attempts to update a config
func (cli *Client) ConfigUpdate(ctx context.Context, id string, version swarm.Version, config swarm.ConfigSpec) error {
	if err := cli.NewVersionError(ctx, "1.30", "config update"); err != nil {
		return err
	}
	query := url.Values{}
	query.Set("version", version.String())
	resp, err := cli.post(ctx, "/configs/"+id+"/update", query, config, nil)
	ensureReaderClosed(resp)
	return err
}

待配置结构体swarm.ConfigSpec信息如下：

// ConfigSpec represents a config specification from a config in swarm
type ConfigSpec struct {
	Annotations
	Data []byte `json:",omitempty"`

	// Templating controls whether and how to evaluate the config payload as
	// a template. If it is not set, no templating is used.
	Templating *Driver `json:",omitempty"`
}

Annotations字段信息如下：

// Annotations represents how to describe an object.
type Annotations struct {
	Name   string            `json:",omitempty"`
	Labels map[string]string `json:"Labels"`
}

容器函数库

将上面的各个函数集成到一个文件，形成一个函数库，便于用户使用和调用。

package main

import (
	"context"
	"encoding/json"
	"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"
	"github.com/docker/go-connections/nat"
	"github.com/opencontainers/image-spec/specs-go/v1"
	"io"
	"log"
	"os"
)

func main() {
	cli, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
	if err != nil {
		log.Fatal(err)
	}
	//查找容器信息
	getInfoOptions := types.ContainerListOptions{}
	getContainerInfo(cli, getInfoOptions)

	//配置创建容器的属性
	containerConfig := &container.Config{
		Image: "my-golang-app",
		ExposedPorts: nat.PortSet{
			"3889/tcp": {},
		},
	}

	//配置容器主机的属性
	//主要用于配置容器的运行环境和资源限制等主机级别的设置
	//配置的是容器的主机配置，而不是宿主机（即物理计算机或虚拟机）的主机配置。
	hostConfig := &container.HostConfig{}

	//主要用于配置容器的网络连接和端口映射等网络设置
	networkingConfig := &network.NetworkingConfig{}

	//主要用于指定容器的运行平台信息，以便 Docker 在部署时选择合适的环境。
	platformConfig := &v1.Platform{}

	//创建的容器名字,唯一标识
	containerName := "mycontainer-30"

	//调用createContainer创建容器并启动
	containerId, err := createContainer(cli, containerConfig, hostConfig, networkingConfig, platformConfig, containerName)
	fmt.Printf("容器%s已创建好 ", containerId)

	// 删除容器是通过Id进行删除的,需要根据名字查找到容器Id
	// 根据容器的名字查找出要删除容器的Id
	containerID, err := getContainerIDByName(cli, containerName)
	if err != nil {
		log.Fatal(err)
	}

	// 定义删除容器时的选项
	removeOptions := types.ContainerRemoveOptions{
		Force:         true,  // 强制删除容器
		RemoveVolumes: true,  // 删除关联的数据卷
		RemoveLinks:   false, // 不删除关联的链接
	}
	// 调用removeContainer删除容器
	removeContainer(cli, containerID, removeOptions)

	//根据容器的新配置重新创建容器
	reUpdateContainer(cli, removeOptions, containerConfig, hostConfig, networkingConfig, platformConfig, containerName)

	// 停止容器
	stopOptions := container.StopOptions{}
	stopContainer(cli, containerID, stopOptions)
	// 重启容器
	restartContainer(cli, containerID, stopOptions)

	// 暂停容器
	pauseContainer(cli, containerID)
	// 恢复暂停
	unpauseContainer(cli, containerID)

	// 定义进入容器时的选项
	attachOptions := types.ContainerAttachOptions{
		Stream: true,
		Stdin:  true,
		Stdout: true,
		Stderr: true,
	}
	attachContainer(cli, containerID, attachOptions)

	// 定义以命令行进入容器的选项
	execAttachConfig := types.ExecConfig{
		Cmd:          []string{"sh"},
		AttachStdin:  true,
		AttachStdout: true,
		AttachStderr: true,
		Tty:          true,
	}
	execAttachCheck := types.ExecStartCheck{
		Tty: true,
	}
	execAttachContainer(cli, containerID, execAttachConfig, execAttachCheck)

	// 定义拉取镜像的选项
	// 定义要拉取的镜像的名称和标签
	imageName := "redis"
	imageTag := "latest"
	imageRef := imageName + ":" + imageTag
	imagePulloptions := types.ImagePullOptions{}
	pullImage(cli, imageRef, imagePulloptions)

	//获取容器内所有镜像的信息
	getImageOptions := types.ImageListOptions{}
	err = getAllImagesInfo(cli, getImageOptions)
	if err != nil {
		log.Fatal(err)
	}

	// 定义更新容器的选项
	// 更新容器配置信息
	// 配置更新
	updateConfig := container.UpdateConfig{
		Resources: container.Resources{
			// Minimum memory limit allowed is 6MB
			// 单位为byte(字节数)
			Memory:     60000000,
			MemorySwap: 60000000, //设置Memory小于交换内存MemorySwap 需要同时配置MemorySwap
			NanoCPUs:   1,        // 设置 CPU 配额（以纳秒为单位）范围: 0.01 - 8.00
		},
	}
	err = updateContainer(cli, containerID, updateConfig)
	if err != nil {
		log.Fatal(err)
	}

}

/*
作用: 查找出容器的所有信息(容器ID、镜像名、端口、运行状态等等)
*/
func getContainerInfo(cli *client.Client, getInfoOptions types.ContainerListOptions) {
	// 先得到列出所有容器的列表
	containers, err := cli.ContainerList(context.Background(), getInfoOptions)
	if err != nil {
		panic(err)
	}

	// 对应为docker ps -a 命令
	// 再从列表(map)中拿到信息
	for _, container := range containers {
		fmt.Printf("CONTAINER ID: %s\n", container.ID)
		fmt.Printf("IMAGE: %s \n", container.Image)
		fmt.Printf("COMMAND: %s \n", container.Command)
		fmt.Printf("CREATED: %s \n", container.Created)
		fmt.Printf("Status: %s \n", container.Status)
		fmt.Printf("PORTS: %s \n", container.Ports)
		fmt.Printf("NAMES：%s\n", container.Names)
	}
}

/*
作用: 根据容器名字和配置的创建选项创建容器
*/
func createContainer(cli *client.Client, containerConfig *container.Config, hostConfig *container.HostConfig, networkingConfig *network.NetworkingConfig, platformConfig *v1.Platform, containerName string) (containerId string, err error) {
	// 创建容器
	resp, err := cli.ContainerCreate(context.Background(), containerConfig, hostConfig, networkingConfig, platformConfig, containerName)
	if err != nil {
		log.Fatal(err)
	}
	// 启动容器
	if err := cli.ContainerStart(context.Background(), resp.ID, types.ContainerStartOptions{}); err != nil {
		log.Fatal(err)
	}
	//返回创建好的容器ID
	return resp.ID, err
}

/*
作用: 根据容器ID和配置的删除选项删除容器
*/
func removeContainer(cli *client.Client, containerID string, removeOptions types.ContainerRemoveOptions) {
	// 调用 ContainerRemove 方法删除容器
	err := cli.ContainerRemove(context.Background(), containerID, removeOptions)
	if err != nil {
		fmt.Printf("Failed to remove container: %v\n", err)
	} else {
		fmt.Println("Container removed successfully")
	}
}

/*
作用: 根据容器ID和配置的停止选项停止容器
*/
func stopContainer(cli *client.Client, containerID string, stopOptions container.StopOptions) {
	// 调用 ContainerStop 方法停止容器
	err := cli.ContainerStop(context.Background(), containerID, stopOptions)
	if err != nil {
		fmt.Printf("Failed to stop container: %v\n", err)
	} else {
		fmt.Println("Container stopped successfully")
	}
}

/*
作用: 根据容器ID和配置的停止选项重启容器
*/
func restartContainer(cli *client.Client, containerID string, stopOptions container.StopOptions) {
	// 调用 ContainerRestart 方法重启容器
	err := cli.ContainerRestart(context.Background(), containerID, stopOptions)
	if err != nil {
		panic(err)
	}

	fmt.Printf("Container %s has been restarted.\n", containerID)
}

/*
作用: 根据容器ID暂停容器
*/
func pauseContainer(cli *client.Client, containerID string) {
	// 暂停容器
	err := cli.ContainerPause(context.Background(), containerID)
	if err != nil {
		fmt.Printf("Failed to pause container: %v\n", err)
	} else {
		fmt.Println("Container paused successfully")
	}
}

/*
作用: 根据容器ID恢复容器暂停
*/
func unpauseContainer(cli *client.Client, containerID string) {
	// 恢复暂停
	err := cli.ContainerUnpause(context.Background(), containerID)
	if err != nil {
		fmt.Printf("Failed to pause container: %v\n", err)
	} else {
		fmt.Println("Container paused successfully")
	}
}

/*
作用: 根据容器ID和配置的进入选项进入容器内部
*/
func attachContainer(cli *client.Client, containerID string, attachOptions types.ContainerAttachOptions) {
	// 调用 ContainerAttach 方法进入容器
	resp, err := cli.ContainerAttach(context.Background(), containerID, attachOptions)
	if err != nil {
		panic(err)
	}
	defer resp.Close()

	// 将容器的标准输入输出连接到当前进程的标准输入输出
	go io.Copy(os.Stdout, resp.Reader)
	go io.Copy(resp.Conn, os.Stdin)

	// 等待用户输入以继续运行
	fmt.Println("Press enter to exit...")
	fmt.Scanln()
}

/*
作用: 通过容器ID配置的进入选项以命令行的方式进入容器内部
*/
func execAttachContainer(cli *client.Client, containerID string, execAttachConfig types.ExecConfig, execAttachCheck types.ExecStartCheck) {
	// 准备执行命令的选项
	createResp, err := cli.ContainerExecCreate(context.Background(), containerID, execAttachConfig)
	if err != nil {
		panic(err)
	}

	// 连接到正在运行的命令以进行交互
	resp, err := cli.ContainerExecAttach(context.Background(), createResp.ID, execAttachCheck)
	if err != nil {
		panic(err)
	}
	defer resp.Close()

	// 将容器的标准输入输出连接到当前进程的标准输入输出
	go func() {
		if _, err := io.Copy(os.Stdout, resp.Reader); err != nil {
			panic(err)
		}
	}()

	go func() {
		if _, err := io.Copy(resp.Conn, os.Stdin); err != nil {
			panic(err)
		}
	}()

	// 等待用户输入以继续运行
	fmt.Println("Press enter to exit...")
	fmt.Scanln()
}

/*
作用: 通过配置拉取的镜像名和拉取选项拉取镜像
*/
func pullImage(cli *client.Client, imageRef string, imagePulloptions types.ImagePullOptions) {
	// 拉取镜像
	out, err := cli.ImagePull(context.Background(), imageRef, imagePulloptions)
	if err != nil {
		panic(err)
	}
	defer out.Close()

	// 解析拉取镜像的输出
	var pullResponse struct {
		Status string `json:"status"`
	}
	if err := json.NewDecoder(out).Decode(&pullResponse); err != nil {
		panic(err)
	}

	fmt.Printf("Pulling image %s: %s\n", imageRef, pullResponse.Status)
}

/*
作用: 通过容器ID和编写的更新配置动态更新容器配置信息(主要是资源限制、重启选项)
*/
func updateContainer(cli *client.Client, containerID string, updateConfig container.UpdateConfig) error {
	// 执行容器更新
	_, err := cli.ContainerUpdate(context.Background(), containerID, updateConfig)
	if err != nil {
		return err
	}
	fmt.Println("容器配置已更新")
	return nil
}

/*
作用: 根据容器名字和容器的新配置创建容器,用于对容器的配置进行静态的修改。
*/
func reUpdateContainer(cli *client.Client, removeOptions types.ContainerRemoveOptions, containerConfig *container.Config, hostConfig *container.HostConfig, networkingConfig *network.NetworkingConfig, platformConfig *v1.Platform, containerName string) {
	// 一开始调用函数时就要传入创建、删除容器的配置
	//传入要删除的名字,得到要删除的容器ID。
	containerID, err := getContainerIDByName(cli, containerName)
	if err != nil {
		log.Fatal(err)
	}
	//删除容器
	removeContainer(cli, containerID, removeOptions)

	//调用创建api,创建新的容器
	containerId, err := createContainer(cli, containerConfig, hostConfig, networkingConfig, platformConfig, containerName)
	fmt.Printf("容器%s已重新创建好 ", containerId)
}

/*
作用:通过容器名查找容器ID,常用于需要使用容器ID的容器操作
*/
func getContainerIDByName(cli *client.Client, containerName string) (string, error) {
	containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{})
	if err != nil {
		return "", err
	}

	for _, container := range containers {
		for _, name := range container.Names {
			// 注意: 容器名字以 "/" 开头，例如：你创建的名字为mycontainer-30 实际在容器中为"/mycontainer-30"
			// 在查找时前面要拼接上一个 /
			if name == "/"+containerName {
				return container.ID, nil
			}
		}
	}
	return "", fmt.Errorf("未找到容器名称为 %s 的容器", containerName)
}

/*
作用: 获取容器的所有镜像信息(不包含镜像的名字)
*/
func getAllImagesInfo(cli *client.Client, getImageOptions types.ImageListOptions) error {
	// 调用 Docker API 获取所有镜像的摘要信息
	images, err := cli.ImageList(context.Background(), getImageOptions)
	if err != nil {
		return err
	}

	// 打印每个镜像的信息
	for _, image := range images {
		fmt.Printf("镜像ID: %s\n", image.ID)
		fmt.Printf("标签: %s\n", image.Labels["com.docker.compose.version"])
		fmt.Printf("大小: %d bytes\n", image.Size)
		fmt.Println("--------------")
	}
	return nil
}

往期好文💕

保姆级教程

【保姆级教程】Windows11下go-zero的etcd安装与初步使用

【保姆级教程】Windows11安装go-zero代码生成工具goctl、protoc、go-zero

【Go-Zero】手把手带你在goland中创建api文件并设置高亮

报错解决

【Go-Zero】Error: user.api 27:9 syntax error: expected ‘:‘ | ‘IDENT‘ | ‘INT‘, got ‘(‘ 报错解决方案及api路由注意事项

【Go-Zero】Error: only one service expected goctl一键转换生成rpc服务错误解决方案

【Go-Zero】【error】 failed to initialize database, got error Error 1045 (28000):报错解决方案

【Go-Zero】Error 1045 (28000): Access denied for user ‘root‘@‘localhost‘ (using password: YES)报错解决方案

【Go-Zero】type mismatch for field “Auth.AccessSecret“, expect “string“, actual “number“报错解决方案

【Go-Zero】Error: user.api 30:2 syntax error: expected ‘)‘ | ‘KEY‘, got ‘IDENT‘报错解决方案

【Go-Zero】Windows启动rpc服务报错panic:context deadline exceeded解决方案

Go面试向

【Go面试向】defer与time.sleep初探

【Go面试向】defer与return的执行顺序初探

【Go面试向】Go程序的执行顺序

【Go面试向】rune和byte类型的认识与使用

【Go面试向】实现map稳定的有序遍历的方式

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1510851.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【Java从发入门到精通】Java StringBuffer 和 StringBuilder 类

【Java从发入门到精通】Java StringBuffer 和 StringBuilder 类

Java StringBuffer 和 StringBuilder 类 当对字符串进行修改的时候&#xff0c;需要使用 StringBuffer 和 StringBuilder 类。 和 String 类不同的是&#xff0c;StringBuffer 和 StringBuilder 类的对象能够被多次的修改&#xff0c;并且不产生新的未使用对象。 在使用 Stri…
阅读更多...
#QT（QSpinBox,QDoubleSpinBox）

#QT（QSpinBox,QDoubleSpinBox）

1.IDE&#xff1a;QTCreator 2.实验:实现一个计价工具&#xff0c;进制转换工具。 教程来自&#xff1a;阿西拜编程 QT C 5.9 3.记录 设置进制的第二种方法 ui->hex_tx->setDisplayIntegerBase(16); //设置显示进制为16进制 4.代码 widget.cpp #include "wi…
阅读更多...
NOIP2018-S-DAY1-3-赛道修建（洛谷P5021)的题解

NOIP2018-S-DAY1-3-赛道修建（洛谷P5021)的题解

目录 题目 原题描述&#xff1a; 题目描述 输入格式 输出格式 输入输出样例 主要思路&#xff1a; check&#xff1a; 真正的code: 原题描述&#xff1a; 题目描述 C 城将要举办一系列的赛车比赛。在比赛前&#xff0c;需要在城内修建 条赛道。 C 城一共有 个路…
阅读更多...
天梯赛的赛场安排（Python）

天梯赛的赛场安排（Python）

作者 陈越 单位 浙江大学 天梯赛使用 OMS 监考系统&#xff0c;需要将参赛队员安排到系统中的虚拟赛场里&#xff0c;并为每个赛场分配一位监考老师。每位监考老师需要联系自己赛场内队员对应的教练们&#xff0c;以便发放比赛账号。为了尽可能减少教练和监考的沟通负担&#…
阅读更多...
打造私人云笔记，创造舒适的写作空间

打造私人云笔记，创造舒适的写作空间

搭建Minio 图片文件服务器 &#xff08;树莓派4B搭建Minio公网云服务器用nps内网穿透&#xff09;Typora 安装客户端 --> 可以利用免费gitee管理文档利用Typora 图像自定义文件上传功能 Minio强大的API功能 一、树莓派4B 64bit raspberry 操作系统 Docker Minio 图片文件…
阅读更多...
CentOS本地部署Tale博客并结合内网穿透实现公网访问本地网站

CentOS本地部署Tale博客并结合内网穿透实现公网访问本地网站

文章目录 前言1. Tale网站搭建1.1 检查本地环境1.2 部署Tale个人博客系统1.3 启动Tale服务1.4 访问博客地址 2. Linux安装Cpolar内网穿透3. 创建Tale博客公网地址4. 使用公网地址访问Tale 前言 今天给大家带来一款基于 Java 语言的轻量级博客开源项目——Tale&#xff0c;Tale…
阅读更多...
Python 配置信息的添加和获取

Python 配置信息的添加和获取

1.效果如下&#xff1a; 2.代码如下&#xff1a; from configparser import ConfigParser import threadingclass Config():_instance_lock threading.Lock()classmethoddef instance(cls, *args, **kwargs):if not hasattr(Config, "_instance"):with Config._ins…
阅读更多...
ELK 基本操作

ELK 基本操作

文章目录 1.Elasticsearch-head2.Kibana2.1.功能简介2.2.Management2.3.Discover2.4.Dev Tools 开源中间件 # Elastic Stackhttps://iothub.org.cn/docs/middleware/ https://iothub.org.cn/docs/middleware/elk/elk-use/1.Elasticsearch-head 2.Kibana 2.1.功能简介 2.2.Man…
阅读更多...
电脑桌面便签下载，电脑桌面便签软件哪个好

电脑桌面便签下载，电脑桌面便签软件哪个好

电脑桌面便签下载&#xff0c;电脑桌面便签软件哪个好&#xff1f;在日常工作生活中&#xff0c;我们经常会遇到许多琐碎的事情需要记录和安排&#xff0c;这时候电脑桌面便签就成为了一个不可或缺的工具。而如今&#xff0c;在电脑时代的今天&#xff0c;电脑桌面便签软件更是…
阅读更多...
扭蛋机小程序，扭蛋与互联网结合下的商机

扭蛋机小程序，扭蛋与互联网结合下的商机

扭蛋机作为一种娱乐消费模式&#xff0c;受众群体不再局限于儿童&#xff0c;也吸引了众多的年轻消费者。扭蛋机具有较大的随机性&#xff0c;玩具商品随机掉落&#xff0c;在购买前消费者完全不知道扭蛋中的商品是什么&#xff0c;这种未知性带来的惊喜感是吸引众多消费者的主…
阅读更多...
MyBatis框架2

MyBatis框架2

目录 一、Sql编写高级特性-批量增删 1.SQL-foreach-批量删除 1.1.批量删除方法 1.2编写SQL 1.3.编写测试 2.动态SQL-foreach-批量插入 2.1.映射器批量插入方法 2.2.编写SQL 2.3.编写测试 二、Sql编写高级特性-多对一 1.多对一保存 1.1.创建员工部门Domain 1.2.创建员…
阅读更多...
远程同声传译如何实现？哪里提供专业的远程同声传译？

远程同声传译如何实现？哪里提供专业的远程同声传译？

远程同传声传译&#xff0c;即线上同传翻译&#xff0c;是指翻译员通过非现场的网络方式进行的同声传译(实时翻译)。远程同声传译的实现依赖于一系列先进的技术手段和高效的协作流程。这一服务模式的出现&#xff0c;不仅打破了传统同声传译的地域限制&#xff0c;还为全球范围…
阅读更多...
【JavaEE Spring 项目】消息队列的设计

【JavaEE Spring 项目】消息队列的设计

消息队列的设计 一、消息队列的背景知识二、需求分析核心概念⼀个⽣产者, ⼀个消费者N 个⽣产者, N 个消费者Broker Server 中的相关概念核⼼ API交换机类型 (Exchange Type)持久化⽹络通信消息应答 三、 模块划分四、 项⽬创建五、创建核心类创建 Exchange创建 MSGQUeue创建 B…
阅读更多...
9个免费游戏后端平台

9个免费游戏后端平台

在这篇文章中&#xff0c;您将看到 九个免费的游戏服务平台提供商&#xff0c;这可以帮助您开始在线多人游戏&#xff0c;而无需预先投入大量资金。 每个提供商都有非常独特的功能&#xff0c;因此成本应该只是决定时要考虑的方面之一。 我还从低预算项目的角度对免费提供商进…
阅读更多...
基于单片机的篮球计分器设计

基于单片机的篮球计分器设计

在当今的体育赛事中，比赛的计分系统对观众和运动员尤为重要，观众可以根据比分的实时显示为自己支持的队伍呐喊助威，运动员更是要靠着计分器来把握比赛的节奏，包括攻防转换、替补换人以及赛间休息等等。因此，为了让比赛进行得更加专业化和流畅化，我们有必要对比赛的计分系…
阅读更多...
基于深度学习的鱼类分类检测系统（含UI界面、yolov8、Python代码、数据集）

基于深度学习的鱼类分类检测系统（含UI界面、yolov8、Python代码、数据集）

项目介绍 项目中所用到的算法模型和数据集等信息如下&#xff1a; 算法模型&#xff1a;     yolov8 yolov8主要包含以下几种创新&#xff1a;         1. 可以任意更换主干结构&#xff0c;支持几百种网络主干。 数据集&#xff1a;     网上下载的数据集&#x…
阅读更多...
MongoDB性能最佳实践：硬件和操作系统配置

MongoDB性能最佳实践：硬件和操作系统配置

欢迎阅读有关MongoDB性能最佳实践的系列博文。在往期文章中&#xff0c;我们已经讨论过查询模式和性能分析、事务和读/写关注等实现大规模性能的关键考虑因素。在本篇文章中&#xff0c;我们将讨论硬件和操作系统配置。 如果您在阿里云上部署MongoDB&#xff0c;那么阿里云会为…
阅读更多...
网站做好这些准备后，上线SEO效果最佳

网站做好这些准备后，上线SEO效果最佳

做网站很多年&#xff0c;也就最近两年理解这个精髓吗。网站上线之前&#xff0c;先在本地做好调试&#xff0c;修改&#xff0c;内容填充。这样后续做SEO会有意想不到的惊喜。 以前我自己做网站&#xff0c;都是直接解析域名到程序安装&#xff0c;上线就是一个空网站&#xf…
阅读更多...
【项目】仿muduo库One Thread One Loop式主从Reactor模型实现高并发服务器

【项目】仿muduo库One Thread One Loop式主从Reactor模型实现高并发服务器

本篇博客记录从0到1实现一个仿mudo库的One Thread One Loop式主从Reactor模型的高并发服务器组件。 在此之前我们要明确的是&#xff0c;该项目仅作为一个高并发服务器组件&#xff0c;因此该项目并不包含实际的业务需求处理内容。 前置知识背景 一、HTTP服务器 概念&#xf…
阅读更多...
双指针算法练习

双指针算法练习

27. 移除元素 题目 给你一个数组 nums 和一个值 val&#xff0c;你需要 原地 移除所有数值等于 val 的元素&#xff0c;并返回移除后数组的新长度。 不要使用额外的数组空间&#xff0c;你必须仅使用 O(1) 额外空间并 原地 修改输入数组。 元素的顺序可以改变。你不需要考虑…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023