Bagaimana untuk menyalin fail tempatan ke bekas pod dalam kluster minikube menggunakan klien Go?

Kandungan soalan

Pertanyaan saya hampir sama dengan tajuk, saya ada fail tempatan file.txt ，我想将其复制到 pod1 的容器 container1 di dalamnya.

Jika saya menggunakan kubectl untuk melakukan ini, arahan yang sesuai ialah:

kubectl cp file.txt pod1:file.txt -c container1

Tetapi bagaimana untuk mencapainya menggunakan klien go kubectl?

Saya mencuba dua kaedah tetapi tidak berjaya:

import (
    "fmt"
    "context"
    "log"
    "os"
    "path/filepath"

    g "github.com/sdslabs/katana/configs"
    v1 "k8s.io/api/core/v1"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/apimachinery/pkg/labels"
    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/rest"
    "k8s.io/client-go/tools/clientcmd"
    //"k8s.io/kubectl/pkg/cmd/exec"
)

func copyintopod(namespace string, podname string, containername string, srcpath string, dstpath string) {
    // create a kubernetes client
    config, err := getkubeconfig()
    if err != nil {
        log.fatal(err)
    }

    client, err := kubernetes.newforconfig(config)
    if err != nil {
        log.fatal(err)
    }

    // build the command to execute
    cmd := []string{"cp", srcpath, dstpath}

    // use the podexecoptions struct to specify the options for the exec request
    options := v1.podexecoptions{
        container: containername,
        command:   cmd,
        stdin:     false,
        stdout:    true,
        stderr:    true,
        tty:       false,
    }
    log.println("options set!")

    // use the corev1api.exec method to execute the command inside the container
    req := client.corev1().restclient().post().
        namespace(namespace).
        name(podname).
        resource("pods").
        subresource("exec").
        versionedparams(&options, metav1.parametercodec)
    log.println("request generated")
    
    exec, err := req.stream(context.todo())
    if err != nil {
        log.fatal(err)
    }
    defer exec.close()

    // read the response from the exec command
    var result []byte
    if _, err := exec.read(result); err != nil {
        log.fatal(err)
    }

    fmt.println("file copied successfully!")
}

Ini memberi saya mesej ralat:

no 类型已在方案“pkg/runtime/scheme.go:100” Berdaftar untuk jenis v1.podexecoptions

Saya tidak dapat memahaminya, jadi saya mencuba kaedah lain:

type PodExec struct {
    RestConfig *rest.Config
    *kubernetes.Clientset
}

func NewPodExec(config *rest.Config, clientset *kubernetes.Clientset) *PodExec {
    config.APIPath = "/api" // Make sure we target /api and not just /
    config.GroupVersion = &schema.GroupVersion{Version: "v1"} // this targets the core api groups so the url path will be /api/v1
    config.NegotiatedSerializer = serializer.WithoutConversionCodecFactory{CodecFactory: scheme.Codecs}
    return &PodExec{
      RestConfig: config,
      Clientset:  clientset,
    }  
}

func (p *PodExec) PodCopyFile(src string, dst string, containername string, podNamespace string) (*bytes.Buffer, *bytes.Buffer, *bytes.Buffer, error) {
    ioStreams, in, out, errOut := genericclioptions.NewTestIOStreams()
    copyOptions := cp.NewCopyOptions(ioStreams)
    copyOptions.Clientset = p.Clientset
    copyOptions.ClientConfig = p.RestConfig
    copyOptions.Container = containername
    copyOptions.Namespace = podNamespace
    err := copyOptions.Run()
    if err != nil {
        return nil, nil, nil, fmt.Errorf("could not run copy operation: %v", err)
    }
    return in, out, errOut, nil
}

Walau bagaimanapun, copyoptions.run()命令存在一些问题，它尝试在copyoptions内查找o.args[0]和o.args[0]，但otidak diimport dan oleh itu tidak boleh diimport untuk pengubahsuaian.

Konteks: https://pkg.go.dev/k8s.io/kubectl/pkg/cmd/cp#copyoptions.run

Jadi, sekarang saya betul-betul sesat dan keliru. Sebarang bantuan amatlah dihargai. terima kasih.

EDIT: Saya memang memikirkan cara yang mungkin di mana kita boleh memanggil arahan cmd.exec() 并直接运行 kubectl cp terus, tetapi nampaknya agak sukar dan saya tidak pasti sama ada ia akan berfungsi, ada idea?

Jawapan Betul

Beginilah akhirnya saya berjaya melakukannya:

package main

import (
    "context"
    "fmt"
    "os"
    "path/filepath"

    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/kubernetes/scheme"
    corev1 "k8s.io/api/core/v1"
    "k8s.io/client-go/tools/clientcmd"
    "k8s.io/client-go/util/homedir"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/client-go/tools/remotecommand"
)

func CopyIntoPod(podName string, namespace string, containerName string, srcPath string, dstPath string) {
    // Get the default kubeconfig file
    kubeConfig := filepath.Join(homedir.HomeDir(), ".kube", "config")

    // Create a config object using the kubeconfig file
    config, err := clientcmd.BuildConfigFromFlags("", kubeConfig)
    if err != nil {
        fmt.Printf("Error creating config: %s\n", err)
        return
    }

    // Create a Kubernetes client
    client, err := kubernetes.NewForConfig(config)
    if err != nil {
        fmt.Printf("Error creating client: %s\n", err)
        return
    }

    // Open the file to copy
    localFile, err := os.Open(srcPath)
    if err != nil {
        fmt.Printf("Error opening local file: %s\n", err)
        return
    }
    defer localFile.Close()

    pod, err := client.CoreV1().Pods(namespace).Get(context.TODO(), podName, metav1.GetOptions{})
    if err != nil {
        fmt.Printf("Error getting pod: %s\n", err)
        return
    }

    // Find the container in the pod
    var container *corev1.Container
    for _, c := range pod.Spec.Containers {
        if c.Name == containerName {
            container = &c
            break
        }
    }

    if container == nil {
        fmt.Printf("Container not found in pod\n")
        return
    }

    // Create a stream to the container
    req := client.CoreV1().RESTClient().Post().
        Resource("pods").
        Name(podName).
        Namespace(namespace).
        SubResource("exec").
        Param("container", containerName)   

    req.VersionedParams(&corev1.PodExecOptions{
        Container: containerName,
        Command:   []string{"bash", "-c", "cat > " + dstPath},
        Stdin:     true,
        Stdout:    true,
        Stderr:    true,
    }, scheme.ParameterCodec)

    exec, err := remotecommand.NewSPDYExecutor(config, "POST", req.URL())
    if err != nil {
        fmt.Printf("Error creating executor: %s\n", err)
        return
    }

    // Create a stream to the container
    err = exec.StreamWithContext(context.TODO(), remotecommand.StreamOptions{
        Stdin:  localFile,
        Stdout: os.Stdout,
        Stderr: os.Stderr,
        Tty:    false,
    })
    if err != nil {
        fmt.Printf("Error streaming: %s\n", err)
        return
    }

    fmt.Println("File copied successfully")
}

Atas ialah kandungan terperinci Bagaimana untuk menyalin fail tempatan ke bekas pod dalam kluster minikube menggunakan klien Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!