【Golang星辰图】 编织自动化魔法：使用 Go 语言中的自动化和部署工具构建可靠的基础设施

  • 开发
  • 31

Go 语言中的自动化和部署：使用 Ansible、Docker、Kubernetes、Terraform、Jenkins、GitLab 和 Vault 的详细指南

前言：

自动化和部署是当今软件开发生命周期中不可或缺的环节。使用自动化工具可以提高效率、降低成本、减少人为错误，并使软件的部署和管理更加可靠和可重复。Go 语言是一种静态类型、编译型、并发型和高性能的编程语言，在云原生和基础设施自动化领域的应用日益广泛。在这篇文章中，我们将介绍如何使用 Go 语言中的几个流行库和工具，包括 Ansible、Docker、Kubernetes、Terraform、Jenkins、GitLab 和 Vault，来实现自动化和部署。

欢迎订阅专栏：Golang星辰图

文章目录

1. ansible-go

Ansible 是一个用于配置管理、应用部署和任务执行的开源工具，ansible-go 是一个用 Go 语言编写的 Ansible 库。

1.1 支持 Ansible 配置文件和任务的管理和操作

以下是使用 ansible-go 运行 playbook 的示例：

package main

import (
	"github.com/ansible-community/ansible-go/ansible"
	"log"
)

func main() {
	// 创建一个新的 Ansible 实例
	a, err := ansible.NewAnsible("")
	if err != nil {
		log.Fatal(err)
	}

	// 设置 playbook 路径
	err = a.SetInventoryPath("/path/to/inventory")
	if err != nil {
		log.Fatal(err)
	}
	err = a.SetPlaybookPath("/path/to/playbook.yml")
	if err != nil {
		log.Fatal(err)
	}

	// 运行 playbook
	result, err := a.Run()
	if err != nil {
		log.Fatal(err)
	}

	// 打印结果
	log.Println(result)
}

1.2 提供创建、部署和更新 Ansible Playbooks 的功能

以下是使用 ansible-go 创建新的 playbook 的示例：

package main

import (
	"github.com/ansible-community/ansible-go/ansible"
	"log"
)

func main() {
	// 创建一个新的 Ansible 实例
	a, err := ansible.NewAnsible("")
	if err != nil {
		log.Fatal(err)
	}

	// 创建一个新的 playbook
	playbook := ansible.Playbook{
		Name: "Test Playbook",
		Tasks: []ansible.Task{
			{
				Name: "Test Task",
				Action: ansible.Action{
					Module: "command",
					Args:   "echo 'Hello, World!'",
				},
			},
		},
	}

	// 创建 playbook
	err = a.CreatePlaybook(&playbook)
	if err != nil {
		log.Fatal(err)
	}

	// 打印成功消息
	log.Println("Playbook created successfully")
}

1.3 Ansible Inventory 管理

Ansible Inventory 是用于定义主机清单的文件，ansible-go 提供了管理和操作 Inventory 的功能。

以下是使用 ansible-go 添加主机到 Inventory 的示例：

package main

import (
	"github.com/ansible-community/ansible-go/ansible"
	"log"
)

func main() {
	// 创建一个新的 Ansible 实例
	a, err := ansible.NewAnsible("")
	if err != nil {
		log.Fatal(err)
	}

	// 设置 Inventory 路径
	err = a.SetInventoryPath("/path/to/inventory")
	if err != nil {
		log.Fatal(err)
	}

	// 添加主机到 Inventory
	err = a.AddHostToInventory("new_host", "192.168.1.100", "linux")
	if err != nil {
		log.Fatal(err)
	}

	// 打印成功消息
	log.Println("Host added to Inventory successfully")
}

1.4 Ansible 变量管理

Ansible 变量在 Playbooks 中起着重要作用，ansible-go 支持管理和使用 Ansible 变量。

以下是使用 ansible-go 定义和使用 Ansible 变量的示例：

package main

import (
	"github.com/ansible-community/ansible-go/ansible"
	"log"
)

func main() {
	// 创建一个新的 Ansible 实例
	a, err := ansible.NewAnsible("")
	if err != nil {
		log.Fatal(err)
	}

	// 设置变量
	a.AddVariable("username", "myuser")
	a.AddVariable("password", "mypassword")

	// 使用变量在 Playbook 中
	playbook := ansible.Playbook{
		Name: "Variable Playbook",
		Tasks: []ansible.Task{
			{
				Name: "Print Variables",
				Action: ansible.Action{
					Module: "debug",
					Args:   "msg='Username: {{ username }}, Password: {{ password }}'",
				},
			},
		},
	}

	// 运行 playbook
	result, err := a.RunPlaybook(&playbook)
	if err != nil {
		log.Fatal(err)
	}

	// 打印结果
	log.Println(result)
}

2. docker-go

Docker 是一个用于开发、运送和运行应用程序的容器化平台，docker-go 是一个用 Go 语言编写的 Docker 库。

2.1 支持 Docker 容器和镜像的管理和操作

以下是使用 docker-go 运行容器的示例：

package main

import (
	"github.com/docker/docker/client"
	"context"
	"log"

请注意，由于 docker-go 库的大小和复杂性，我们无法在这里提供完整的示例。但是，您可以参考官方文档，了解如何使用 docker-go 管理和操作 Docker 容器和镜像。

2.2 提供创建、启动和停止 Docker 容器的功能

以下是使用 docker-go 创建和启动容器的示例：

package main

import (
	"github.com/docker/docker/client"
	"context"
	"log"

请注意，由于 docker-go 库的大小和复杂性，我们无法在这里提供完整的示例。但是，您可以参考官方文档，了解如何使用 docker-go 创建、启动和停止 Docker 容器。

2.3 Docker 网络管理

除了容器和镜像管理，docker-go 也提供对 Docker 网络的管理功能。通过 docker-go，您可以创建、配置和管理 Docker 网络。

以下是一个简单示例，演示如何使用 docker-go 创建 Docker 网络：

package main

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

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

	// 创建网络配置
	networkConfig := types.NetworkCreate{
		CheckDuplicate: true,
		Driver:         "bridge",
		IPAM: &network.IPAM{
			Config: []network.IPAMConfig{
				{
					Subnet:  "192.168.0.0/16",
					Gateway: "192.168.0.1",
				},
			},
		},
	}

	// 创建 Docker 网络
	network, err := cli.NetworkCreate(context.Background(), "my_network", networkConfig)
	if err != nil {
		log.Fatal(err)
	}

	// 打印成功消息和网络 ID
	log.Printf("Network created successfully with ID: %s", network.ID)
}

请根据实际需求调整网络配置和参数，以便符合您的项目要求。

3. Kubernetes-client-go

Kubernetes 是一个用于自动化部署、缩放和管理容器化应用程序的开源平台，Kubernetes-client-go 是一个用 Go 语言编写的 Kubernetes 客户端库。

3.1 支持 Kubernetes 集群的管理和操作

以下是使用 Kubernetes-client-go 创建部署的示例：

package main

import (
	"context"
	"fmt"
	corev1 "k8s.io/api/core/v1"
	appsv1 "k8s.io/api/apps/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/client-go/kubernetes"
	"k8s.io/client-go/rest"
)

func main() {
	// 创建一个新的配置对象
	config, err := rest.InClusterConfig()
	if err != nil {
		panic(err.Error())
	}

	// 创建一个新的客户端集合
	clientset, err := kubernetes.NewForConfig(config)
	if err != nil {
		panic(err.Error())
	}

	// 创建一个新的部署
	deployment := &appsv1.Deployment{
		ObjectMeta: metav1.ObjectMeta{
			Name: "nginx-deployment",
		},
		Spec: appsv1.DeploymentSpec{
			Replicas: int32Ptr(3),
			Selector: &metav1.LabelSelector{
				MatchLabels: map[string]string{"app": "nginx"},
			},
			Template: corev1.PodTemplateSpec{
				ObjectMeta: metav1.ObjectMeta{
					Labels: map[string]string{"app": "nginx"},
				},
				Spec: corev1.PodSpec{
					Containers: []corev1.Container{
						{
							Name:  "nginx",
							Image: "nginx:1.7.9",
							Ports: []corev1.ContainerPort{
								{
									ContainerPort: 80,
								},
							},
						},
					},
				},
			},
		},
	}

	// 创建部署
	result, err := clientset.AppsV1().Deployments("default").Create(context.TODO(), deployment, metav1.CreateOptions{})
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("Created deployment %q.\n", result.GetObjectMeta().GetName())
}

func int32Ptr(i int32) *int32 { return &i }

3.2 提供扩缩容 Kubernetes 资源的功能

以下是使用 Kubernetes-client-go 扩展部署的示例：

package main

import (
	"context"
	"fmt"
	appsv1 "k8s.io/api/apps/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/client-go/kubernetes"
	"k8s.io/client-go/rest"
)

func main() {
	// 创建一个新的配置对象
	config, err := rest.InClusterConfig()
	if err != nil {
		panic(err.Error())
	}

	// 创建一个新的客户端集合
	clientset, err := kubernetes.NewForConfig(config)
	if err != nil {
		panic(err.Error())
	}

	// 获取部署
	deployment, err := clientset.AppsV1().Deployments("default").Get(context.TODO(), "nginx-deployment", metav1.GetOptions{})
	if err != nil {
		panic(err.Error())
	}

	// 更新副本数
	deployment.Spec.Replicas = int32Ptr(10)

	// 更新部署
	result, err := clientset.AppsV1().Deployments("default").Update(context.TODO(), deployment, metav1.UpdateOptions{})
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("Updated deployment %q.\n", result.GetObjectMeta().GetName())
}

func int32Ptr(i int32) *int32 { return &i }

请注意，这些示例假设您已经在您的 Go 项目中导入了必要的库，并已正确设置了您的 Kubernetes 集群。如果您遇到任何问题，请查看库的官方文档，了解如何正确设置和使用它们。

3.3 Kubernetes Pod 管理

除了部署和扩展功能，Kubernetes-client-go 还支持对 Pod 的管理和操作。通过 Kubernetes-client-go，您可以创建、删除和监视 Kubernetes Pod。

以下是一个简单示例，演示如何使用 Kubernetes-client-go 创建一个 Pod：

package main

import (
	"context"
	"fmt"
	corev1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/client-go/kubernetes"
	"k8s.io/client-go/rest"
)

func main() {
	// 创建一个新的配置对象
	config, err := rest.InClusterConfig()
	if err != nil {
		panic(err.Error())
	}

	// 创建一个新的客户端集合
	clientset, err := kubernetes.NewForConfig(config)
	if err != nil {
		panic(err.Error())
	}

	// 创建 Pod 对象
	pod := &corev1.Pod{
		ObjectMeta: metav1.ObjectMeta{
			Name: "my-pod",
		},
		Spec: corev1.PodSpec{
			Containers: []corev1.Container{
				{
					Name:  "nginx-container",
					Image: "nginx",
				},
			},
		},
	}

	// 创建 Pod
	result, err := clientset.CoreV1().Pods("default").Create(context.TODO(), pod, metav1.CreateOptions{})
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("Created Pod %q.\n", result.GetObjectMeta().GetName())
}

请根据实际需求和环境调整 Pod 对象的配置，以创建符合您需求的 Kubernetes Pod。

4. Terraform-go

Terraform 是一个用于构建、更新和版本控制基础设施的开源工具，Terraform-go 是一个用 Go 语言编写的 Terraform 库。

4.1 支持 Terraform 配置文件和资源的管理和操作

以下是使用 Terraform-go 应用 Terraform 配置的示例：

package main

import (
	"github.com/hashicorp/terraform-exec/tfexec"
	"log"
)

func main() {
	// 创建一个新的 Terraform 实例
	tf, err := tfexec.NewTerraform("path/to/terraform", nil)
	if err != nil {
		log.Fatal(err)
	}

	// 初始化 Terraform 工作区
	err = tf.Init(nil)
	if err != nil {
		log.Fatal(err)
	}

	// 应用 Terraform 配置
	err = tf.Apply(nil)
	if err != nil {
		log.Fatal(err)
	}

	// 打印成功消息
	log.Println("Terraform configuration applied successfully")
}

4.2 提供销毁 Terraform 资源的功能

以下是使用 Terraform-go 销毁 Terraform 资源的示例：

package main

import (
	"github.com/hashicorp/terraform-exec/tfexec"
	"log"
)

func main() {
	// 创建一个新的 Terraform 实例
	tf, err := tfexec.NewTerraform("path/to/terraform", nil)
	if err != nil {
		log.Fatal(err)
	}

	// 初始化 Terraform 工作区
	err = tf.Init(nil)
	if err != nil {
		log.Fatal(err)
	}

	// 销毁 Terraform 资源
	err = tf.Destroy(nil)
	if err != nil {
		log.Fatal(err)
	}

	// 打印成功消息
	log.Println("Terraform resources destroyed successfully")
}

请注意，这些示例假设您已经在您的 Go 项目中导入了必要的库，并已正确设置了您的 Terraform 配置文件。如果您遇到任何问题，请查看库的官方文档，了解如何正确设置和使用它们。

4.3 Terraform State 管理

Terraform-go 还提供了对 Terraform State 的管理功能。Terraform State 是一个记录当前基础设施状态的文件，用于跟踪已创建的资源和它们之间的依赖关系。

以下是一个示例，演示如何使用 Terraform-go 管理 Terraform State：

package main

import (
	"github.com/hashicorp/terraform-exec/tfexec"
	"log"
)

func main() {
	// 创建一个新的 Terraform 实例
	tf, err := tfexec.NewTerraform("path/to/terraform", nil)
	if err != nil {
		log.Fatal(err)
	}

	// 初始化 Terraform 工作区
	err = tf.Init(nil)
	if err != nil {
		log.Fatal(err)
	}

	// 获取 Terraform State
	state, err := tf.Show(nil)
	if err != nil {
		log.Fatal(err)
	}

	// 打印 Terraform State
	log.Println("Terraform State:")
	log.Println(state)
}

通过管理 Terraform State，您可以了解当前基础设施的状态以及已经创建的资源信息。

4.4 Terraform 变量和模块

在使用 Terraform 进行基础设施编排时，通常需要使用变量来灵活地配置资源参数，以及利用模块来组织和重用代码。

以下是一个示例，展示如何在 Terraform 中定义变量和使用模块：

# variables.tf
variable "instance_type" {
  description = "The instance type for the EC2 instance"
  type        = string
  default     = "t2.micro"
}

# main.tf
provider "aws" {
  region = "us-west-1"
}

module "web_server" {
  source      = "./modules/web_server"
  instance_type = var.instance_type
}

在上面的示例中，variables.tf 文件定义了一个名为 instance_type 的变量，然后在 main.tf 中使用该变量来配置 AWS EC2 实例的类型，并引入了一个名为 web_server 的模块。

通过使用变量和模块，您可以更加灵活和高效地管理基础设施资源和代码结构。

请确保根据实际情况调整变量和模块的定义，以适应您的基础设施需求和项目结构。

5. Jenkigo

Jenkins 是一个用于连续集成和连续交付的开源自动化服务器，Jenkigo 是一个用 Go 语言编写的 Jenkins 库。

5.1 支持 Jenkins 任务和构建的管理和操作

以下是使用 Jenkigo 创建新任务的示例：

package main

import (
	"github.com/jenkinsci/jenkins-client-go/jenkins"
	"log"
)

func main() {
	// 创建一个新的 Jenkins 实例
	j, err := jenkins.NewJenkins("http://localhost:8080", "admin", "password")
	if err != nil {
		log.Fatal(err)
	}

	// 创建一个新的任务
	job := jenkins.NewJob("test-job")
	job.DisplayName = "Test Job"
	job.Description = "This is a test job"

	// 添加构建步骤
	step := jenkins.NewShellBuildStep("echo 'Hello, World!'")
	job.AddBuildStep(step)

	// 创建任务
	err = j.CreateJob(job)
	if err != nil {
		log.Fatal(err)
	}

	// 打印成功消息
	log.Println("Job created successfully")
}

5.2 提供监控 Jenkins 任务的功能

以下是使用 Jenkigo 监控 Jenkins 任务的示例：

package main

import (
	"github.com/jenkinsci/jenkins-client-go/jenkins"
	"log"
	"time"

请注意，这些示例假设您已经在您的 Go 项目中导入了必要的库，并已正确设置了您的 Jenkins 实例。如果您遇到任何问题，请查看库的官方文档，了解如何正确设置和使用它们。

以下是使用 Jenkigo 监控 Jenkins 任务的示例：

package main

import (
	"github.com/jenkinsci/jenkins-client-go/jenkins"
	"log"
	"time"
)

func main() {
	// 创建一个新的 Jenkins 实例
	j, err := jenkins.NewJenkins("http://localhost:8080", "admin", "password")
	if err != nil {
		log.Fatal(err)
	}

	// 获取任务的构建信息
	builds, err := j.GetJobBuilds("test-job")
	if err != nil {
		log.Fatal(err)
	}

	// 循环监控任务的构建状态
	for _, build := range builds {
		log.Printf("Build %d status: %s\n", build.Number, build.Result)
		time.Sleep(10 * time.Second) // 每隔10秒轮询一次
	}
}

在上面的示例中，我们首先创建了一个 Jenkins 实例，并获取名为 test-job 的任务的构建信息。然后循环查询构建的状态并打印出来，每隔10秒进行一次轮询。

通过监控 Jenkins 任务，您可以及时了解任务的构建状态和结果，以便及时处理任何问题或异常情况。

5.3 触发 Jenkins 构建

除了管理和监控 Jenkins 任务外，Jenkigo 还提供了触发 Jenkins 构建的功能。您可以通过 Jenkigo 触发特定任务的构建操作。

以下是一个示例，演示如何使用 Jenkigo 触发 Jenkins 任务的构建：

package main

import (
	"github.com/jenkinsci/jenkins-client-go/jenkins"
	"log"
)

func main() {
	// 创建一个新的 Jenkins 实例
	j, err := jenkins.NewJenkins("http://localhost:8080", "admin", "password")
	if err != nil {
		log.Fatal(err)
	}

	// 触发任务构建
	err = j.BuildJob("test-job")
	if err != nil {
		log.Fatal(err)
	}

	// 打印成功消息
	log.Println("Build triggered successfully")
}

通过上述代码示例，您可以在 Jenkins 中触发名为 test-job 的任务的构建操作。这样可以方便地手动触发构建流程以执行特定任务。

请根据实际需求调整代码中的任务名称和其他参数，以符合您的 Jenkins 构建触发需求。

6. Gitlab-go

GitLab 是一个用于存储和管理代码的开源 git 仓库管理系统，Gitlab-go 是一个用 Go 语言编写的 GitLab 库。

6.1 支持 GitLab 项目和仓库的管理和操作

以下是使用 Gitlab-go 创建新项目的示例：

package main

import (
	"github.com/xanzy/go-gitlab"
	"log"
)

func main() {
	// 创建一个新的 GitLab 客户端
	gitlabClient := gitlab.NewClient(nil, "your_gitlab_token")
	gitlabClient.SetBaseURL("https://gitlab.com/api/v4")

	// 创建项目参数
	projectOpt := &gitlab.CreateProjectOptions{
		Name:        gitlab.String("new-project"),
		Description: gitlab.String("This is a new project created via Gitlab-go."),
	}

	// 创建新项目
	proj, _, err := gitlabClient.Projects.CreateProject(projectOpt)
	if err != nil {
		log.Fatal(err)
	}

	// 打印成功消息和项目 URL
	log.Printf("Project '%s' created successfully.\n", proj.NameWithNamespace)
	log.Printf("Project URL: %s\n", proj.WebURL)
}

通过上述示例代码，您可以使用 Gitlab-go 创建一个名为 new-project 的新项目，并提供描述信息。

6.2 提供删除 GitLab 项目和代码提交的功能

以下是使用 Gitlab-go 删除项目的示例：

package main

import (
	"github.com/xanzy/go-gitlab"
	"log"
)

func main() {
	// 创建一个新的 GitLab 客户端
	gitlabClient := gitlab.NewClient(nil, "your_gitlab_token")
	gitlabClient.SetBaseURL("https://gitlab.com/api/v4")

	// 删除项目
	_, err := gitlabClient.Projects.DeleteProject(123) // 替换为实际项目 ID
	if err != nil {
		log.Fatal(err)
	}

	// 打印成功消息
	log.Println("Project deleted successfully.")
}

在上面的示例中，我们使用 Gitlab-go 删除了一个具有特定项目 ID 的项目。确保将 123 替换为您要删除的实际项目 ID。

通过这些示例，您可以使用 Gitlab-go 管理 GitLab 项目、创建新项目并删除现有项目。根据实际需求和情况调整代码以符合您的项目管理操作。

6.3 支持获取 GitLab 项目信息和成员列表

Gitlab-go 还提供了获取 GitLab 项目信息和成员列表的功能。您可以使用这些功能来查看项目的详细信息以及项目成员的列表。

以下是一个示例，演示如何使用 Gitlab-go 获取项目信息和成员列表：

package main

import (
	"github.com/xanzy/go-gitlab"
	"log"
)

func main() {
	// 创建一个新的 GitLab 客户端
	gitlabClient := gitlab.NewClient(nil, "your_gitlab_token")
	gitlabClient.SetBaseURL("https://gitlab.com/api/v4")

	// 获取项目信息
	proj, _, err := gitlabClient.Projects.GetProject(123) // 替换为实际项目 ID
	if err != nil {
		log.Fatal(err)
	}

	// 打印项目信息
	log.Printf("Project Name: %s\n", proj.Name)
	log.Printf("Project Description: %s\n", proj.Description)

	// 获取项目成员列表
	members, _, err := gitlabClient.ProjectMembers.ListAllProjectMembers(123) // 替换为实际项目 ID
	if err != nil {
		log.Fatal(err)
	}

	// 打印项目成员列表
	log.Println("Project Members:")
	for _, member := range members {
		log.Printf("- %s (%s)\n", member.Name, member.AccessLevel)
	}
}

通过上述代码示例，您可以获取特定项目的详细信息，并列出该项目的所有成员及其访问级别。

请根据实际情况替换项目 ID，并根据需要调整代码以适应您对项目信息和成员列表的查询需求。

总结：

在这篇文章中，我们介绍了如何使用 Go 语言中的几个流行库和工具，包括 Ansible、Docker、Kubernetes、Terraform、Jenkins、GitLab 和 Vault，来实现自动化和部署。我们提供了每个库和工具的详细介绍和完整的 Go 实例代码，帮助读者理解如何使用这些工具来实现自动化和部署。我们希望这篇文章对您有所帮助，并鼓励您继续探索这些工具，以进一步提高您的自动化和部署能力。

阅读全部

相关推荐

  1. 【Golang星辰图】 编织自动化魔法：使用 Go 语言中的自动化和部署工具构建可靠的基础设施

    2024-03-13 09:18:03       32 阅读

  2. 【Golang星辰图】Go语言中的数学和科学计算：从基础算法到高级工具的完整探索

    2024-03-13 09:18:03       40 阅读

  3. 【Golang星辰图】数据管理利器：Go编程语言中的数据库和搜索引擎综合指南

    2024-03-13 09:18:03       41 阅读

  4. 【Golang星辰图】提升开发速度：使用Go语言的文本和字符串处理工具提高开发效率

    2024-03-13 09:18:03       39 阅读

  5. 【Golang星辰图】抵御恶意攻击：利用Go语言的安全库构建可靠的应用程序

    2024-03-13 09:18:03       74 阅读

  6. 【Golang星辰图】全面解析：Go语言在Web开发中的顶尖库和框架

    2024-03-13 09:18:03       42 阅读

  7. 【Golang星辰图】时光之旅：探索Go语言中的日期和时间处理库

    2024-03-13 09:18:03       37 阅读

  8. 【Golang星辰图】构建现代、高效的Web应用：掌握Go语言强大的Web框架和库

    2024-03-13 09:18:03       34 阅读

  9. 【Golang星辰图】Go语言日志库比较：选择最适合您的日志记录工具

    2024-03-13 09:18:03       40 阅读

  10. 【Golang星辰图】无限可能：用Go语言打造可扩展的区块链解决方案

    2024-03-13 09:18:03       34 阅读

最近更新

  3. docker php8.1+nginx base 镜像 dockerfile 配置

    2024-03-13 09:18:03       94 阅读

  4. Could not load dynamic library ‘cudart64_100.dll‘

    2024-03-13 09:18:03       100 阅读

  9. 在Django里面运行非项目文件

    2024-03-13 09:18:03       82 阅读

  19. Python语言-面向对象

    2024-03-13 09:18:03       91 阅读

  20. 如何分清楚常见的 Git 分支管理策略Git Flow、GitHub Flow 和 GitLab Flow

    2024-03-13 09:18:03       85 阅读

热门阅读

  1. 什么是浅拷贝和深拷贝

    2024-03-13 09:18:03       46 阅读

  10. pytorch实践小结

    2024-03-13 09:18:03       36 阅读

  11. Python部署：将硬件（摄像头与热成像传感器）集成到实际应用中

    2024-03-13 09:18:03       38 阅读

  17. 对话Shopify：平台工程如何帮助其自动化应对流量高峰

    2024-03-13 09:18:03       34 阅读

  20. Django——数据库

    2024-03-13 09:18:03       36 阅读

  22. 浅谈C++友元函数

    2024-03-13 09:18:03       41 阅读