Add eks port forwarding

Author: hupe1980

README.md

@@ -255,6 +255,7 @@ Usage:
 
 Available Commands:
   exec              Execute a command in a container
+  fwd               Port forwarding
   get-token         Get a token for authentication with an Amazon EKS cluster
   update-kubeconfig Configures kubectl so that you can connect to an Amazon EKS cluster
 
@@ -283,12 +284,38 @@ gotoaws eks exec --cluster gotoaws --role cluster-admin -- cat /etc/passwd
 gotoaws eks exec --cluster gotoaws --role cluster-admin --namespace default --pod nginx -- date
 
 Flags:
-      --cluster string     arn or name of the cluster (required)
+      --cluster string     arn or name of the cluster
   -c, --container string   name of the container
   -h, --help               help for exec
   -n, --namespace string   namespace of the pod (default "all namespaces"
   -p, --pod string         name of the pod
-  -r, --role string        arn or name of the role
+      --role string        arn or name of the role
+
+Global Flags:
+      --config string      config file (default "$HOME/.config/configstore/gotoaws.json")
+      --profile string     AWS profile
+      --region string      AWS region
+      --silent             run gotoaws without printing logs
+      --timeout duration   timeout for network requests (default 15s)
+```
+
+### Port forwarding
+```
+Usage:
+  gotoaws eks fwd [flags]
+
+Examples:
+gotoaws eks fwd --cluster gotoaws --role cluster-admin --pod nginx
+gotoaws eks fwd --cluster gotoaws --role cluster-admin --pod nginx --local 8000 --remote 80
+
+Flags:
+      --cluster string     arn or name of the cluster
+  -h, --help               help for fwd
+  -l, --local int32        the local port
+  -n, --namespace string   namespace of the pod (default "all namespaces"
+  -p, --pod string         name of the pod
+  -r, --remote int32       the container port
+      --role string        arn or name of the role
 
 Global Flags:
       --config string      config file (default "$HOME/.config/configstore/gotoaws.json")

cmd/eks/eks.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/hupe1980/gotoaws/internal"
 	"github.com/hupe1980/gotoaws/pkg/config"
 	"github.com/hupe1980/gotoaws/pkg/eks"
 	"github.com/manifoldco/promptui"
@@ -21,6 +22,7 @@ func NewEKSCmd() *cobra.Command {
 		newUpdateKubeconfigCmd(),
 		newGetTokenCmd(),
 		newExecCmd(),
+		newFwdCmd(),
 	)
 
 	return cmd
@@ -80,6 +82,12 @@ func findPod(cfg *config.Config, cluster *eks.Cluster, role, namespace, podName,
 	}
 
 	if podName != "" {
+		if namespace == "" {
+			internal.PrintInfo("No namspespace was specified. Set namespace to \"default\"")
+
+			namespace = "default"
+		}
+
 		var pods []eks.Pod
 
 		pods, err = finder.FindByIdentifier(namespace, podName, container)

cmd/eks/exec.go

@@ -61,7 +61,7 @@ gotoaws eks exec --cluster gotoaws --role cluster-admin --namespace default --po
 	}
 
 	cmd.Flags().StringVarP(&opts.clusterName, "cluster", "", "", "arn or name of the cluster")
-	cmd.Flags().StringVarP(&opts.role, "role", "r", "", "arn or name of the role")
+	cmd.Flags().StringVarP(&opts.role, "role", "", "", "arn or name of the role")
 	cmd.Flags().StringVarP(&opts.namespace, "namespace", "n", "", "namespace of the pod (default \"all namespaces\"")
 	cmd.Flags().StringVarP(&opts.pod, "pod", "p", "", "name of the pod")
 	cmd.Flags().StringVarP(&opts.container, "container", "c", "", "name of the container")

cmd/eks/fwd.go

@@ -0,0 +1,99 @@
+package eks
+
+import (
+	"errors"
+	"os"
+	"os/signal"
+	"syscall"
+
+	"github.com/hupe1980/gotoaws/internal"
+	"github.com/hupe1980/gotoaws/pkg/eks"
+	"github.com/spf13/cobra"
+)
+
+type fwdOptions struct {
+	clusterName string
+	role        string
+	namespace   string
+	pod         string
+	container   string
+	remotePort  int32
+	localPort   int32
+}
+
+func newFwdCmd() *cobra.Command {
+	opts := &fwdOptions{}
+	cmd := &cobra.Command{
+		Use:           "fwd",
+		Short:         "Port forwarding",
+		SilenceUsage:  true,
+		SilenceErrors: true,
+		Example: `gotoaws eks fwd --cluster gotoaws --role cluster-admin --pod nginx
+gotoaws eks fwd --cluster gotoaws --role cluster-admin --pod nginx --local 8000 --remote 80`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			cfg, err := internal.NewConfigFromFlags()
+			if err != nil {
+				return err
+			}
+
+			cluster, err := findCluster(cfg, opts.clusterName)
+			if err != nil {
+				return err
+			}
+
+			client, err := eks.NewKubeclient(cfg, cluster, opts.role)
+			if err != nil {
+				return err
+			}
+
+			pod, err := findPod(cfg, cluster, opts.role, opts.namespace, opts.pod, opts.container)
+			if err != nil {
+				return err
+			}
+
+			containerPort := opts.remotePort
+			if containerPort == 0 {
+				if len(pod.ContainerPorts) > 0 {
+					containerPort = pod.ContainerPorts[0].Port
+				} else {
+					return errors.New("container port cannot be determined")
+				}
+			}
+
+			stopCh := make(chan struct{}, 1)
+			readyCh := make(chan struct{})
+
+			go func() {
+				<-readyCh
+				internal.PrintInfo("Port forwarding is ready")
+			}()
+
+			sigs := make(chan os.Signal, 1)
+			signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
+			go func() {
+				<-sigs
+				if stopCh != nil {
+					close(stopCh)
+				}
+			}()
+
+			return client.RunPortForward(&eks.PortForwardInput{
+				Namespace:     pod.Namespace,
+				PodName:       pod.Name,
+				LocalPort:     opts.localPort,
+				ContainerPort: containerPort,
+				StopCh:        stopCh,
+				ReadyCh:       readyCh,
+			})
+		},
+	}
+
+	cmd.Flags().StringVarP(&opts.clusterName, "cluster", "", "", "arn or name of the cluster")
+	cmd.Flags().StringVarP(&opts.role, "role", "", "", "arn or name of the role")
+	cmd.Flags().StringVarP(&opts.namespace, "namespace", "n", "", "namespace of the pod (default \"all namespaces\"")
+	cmd.Flags().StringVarP(&opts.pod, "pod", "p", "", "name of the pod")
+	cmd.Flags().Int32VarP(&opts.remotePort, "remote", "r", 0, "the container port")
+	cmd.Flags().Int32VarP(&opts.localPort, "local", "l", 0, "the local port")
+
+	return cmd
+}

pkg/eks/pod.go

@@ -6,6 +6,15 @@ import (
 	"github.com/hupe1980/gotoaws/pkg/config"
 )
 
+// ContainerPort represents a network port in a single container.
+type ContainerPort struct {
+	// Number of port to expose on the pod's IP address
+	Port int32
+
+	// Protocol for port. Must be UDP, TCP, or SCTP.
+	Protocol string
+}
+
 // An object representing a pod.
 type Pod struct {
 	// The name of the pod.
@@ -16,6 +25,9 @@ type Pod struct {
 
 	// The name of the container
 	Container string
+
+	// List of ports to expose from the container
+	ContainerPorts []ContainerPort
 }
 
 type PodFinder interface {
@@ -48,10 +60,22 @@ func (p *podFinder) Find(namespace, labelSelector string) ([]Pod, error) {
 
 	for _, p := range podList.Items {
 		for _, c := range p.Spec.Containers {
+			ports := []ContainerPort{}
+
+			for _, p := range c.Ports {
+				protocol := "TCP"
+				if p.Protocol != "" {
+					protocol = string(p.Protocol)
+				}
+
+				ports = append(ports, ContainerPort{Port: p.ContainerPort, Protocol: protocol})
+			}
+
 			pods = append(pods, Pod{
-				Name:      p.Name,
-				Namespace: p.Namespace,
-				Container: c.Name,
+				Name:           p.Name,
+				Namespace:      p.Namespace,
+				Container:      c.Name,
+				ContainerPorts: ports,
 			})
 		}
 	}
@@ -73,10 +97,22 @@ func (p *podFinder) FindByIdentifier(namespace, podName, container string) ([]Po
 
 	for _, c := range pod.Spec.Containers {
 		if container == "" || container == c.Name {
+			ports := []ContainerPort{}
+
+			for _, p := range c.Ports {
+				protocol := "TCP"
+				if p.Protocol != "" {
+					protocol = string(p.Protocol)
+				}
+
+				ports = append(ports, ContainerPort{Port: p.ContainerPort, Protocol: protocol})
+			}
+
 			pods = append(pods, Pod{
-				Name:      pod.Name,
-				Namespace: pod.Namespace,
-				Container: c.Name,
+				Name:           pod.Name,
+				Namespace:      pod.Namespace,
+				Container:      c.Name,
+				ContainerPorts: ports,
 			})
 		}
 	}

pkg/eks/portforward.go

@@ -0,0 +1,53 @@
+package eks
+
+import (
+	"fmt"
+	"net/http"
+	"os"
+
+	"k8s.io/client-go/tools/portforward"
+	"k8s.io/client-go/transport/spdy"
+)
+
+type PortForwardInput struct {
+	// Namespace of the pod
+	Namespace string
+
+	// Name of the pod
+	PodName string
+
+	// LocalPort is the local port that will be selected to expose the PodPort
+	LocalPort int32
+
+	// ContainerPort is the target port for the pod
+	ContainerPort int32
+
+	// StopCh is the channel used to manage the port forward lifecycle
+	StopCh <-chan struct{}
+
+	// ReadyCh communicates when the tunnel is ready to receive traffic
+	ReadyCh chan struct{}
+}
+
+func (k *Kubeclient) RunPortForward(input *PortForwardInput) error {
+	req := k.clientset.CoreV1().RESTClient().
+		Post().
+		Resource("pods").
+		Namespace(input.Namespace).
+		Name(input.PodName).
+		SubResource("portforward")
+
+	transport, upgrader, err := spdy.RoundTripperFor(k.restCfg)
+	if err != nil {
+		return err
+	}
+
+	dialer := spdy.NewDialer(upgrader, &http.Client{Transport: transport}, http.MethodPost, req.URL())
+
+	fw, err := portforward.New(dialer, []string{fmt.Sprintf("%d:%d", input.LocalPort, input.ContainerPort)}, input.StopCh, input.ReadyCh, os.Stdout, os.Stderr)
+	if err != nil {
+		return err
+	}
+
+	return fw.ForwardPorts()
+}