From 9279954193dc35687d2a6228b4b081101c07cff2 Mon Sep 17 00:00:00 2001 From: aiordache Date: Tue, 20 Apr 2021 10:26:48 +0200 Subject: [PATCH 1/6] Check the status of pod containers on `compose up` Signed-off-by: aiordache --- kube/client/utils.go | 27 +++++++++++++++++++++++++-- 1 file changed, 25 insertions(+), 2 deletions(-) diff --git a/kube/client/utils.go b/kube/client/utils.go index dbe302f8..4368dc7a 100644 --- a/kube/client/utils.go +++ b/kube/client/utils.go @@ -28,11 +28,27 @@ import ( ) func podToContainerSummary(pod corev1.Pod) compose.ContainerSummary { + state := compose.RUNNING + + if pod.DeletionTimestamp != nil { + state = compose.REMOVING + } else { + for _, container := range pod.Status.ContainerStatuses { + if container.State.Waiting != nil || container.State.Terminated != nil { + state = compose.UPDATING + break + } + } + if state == compose.RUNNING && pod.Status.Phase != corev1.PodRunning { + state = string(pod.Status.Phase) + } + } + return compose.ContainerSummary{ ID: pod.GetObjectMeta().GetName(), Name: pod.GetObjectMeta().GetName(), Service: pod.GetObjectMeta().GetLabels()[compose.ServiceTag], - State: string(pod.Status.Phase), + State: state, Project: pod.GetObjectMeta().GetLabels()[compose.ProjectTag], } } @@ -46,6 +62,13 @@ func checkPodsState(services []string, pods []corev1.Pod, status string) (bool, if len(services) > 0 && !utils.StringContains(services, service) { continue } + containersRunning := true + for _, container := range pod.Status.ContainerStatuses { + if container.State.Running == nil { + containersRunning = false + break + } + } servicePods[service] = pod.Status.Message if status == compose.REMOVING { @@ -54,7 +77,7 @@ func checkPodsState(services []string, pods []corev1.Pod, status string) (bool, if pod.Status.Phase == corev1.PodFailed { return false, servicePods, fmt.Errorf(pod.Status.Reason) } - if status == compose.RUNNING && pod.Status.Phase != corev1.PodRunning { + if status == compose.RUNNING && (pod.Status.Phase != corev1.PodRunning || !containersRunning) { stateReached = false } } From bb25812511aae1895a157b44abf019e53144c2fa Mon Sep 17 00:00:00 2001 From: aiordache Date: Tue, 20 Apr 2021 11:55:29 +0200 Subject: [PATCH 2/6] Update existing stack installation on `compose up` instead of returning error Signed-off-by: aiordache --- kube/compose.go | 29 ++++++++++++++++++++++------- kube/helm/helm.go | 13 +++++++++++++ 2 files changed, 35 insertions(+), 7 deletions(-) diff --git a/kube/compose.go b/kube/compose.go index 389c7eae..d998915a 100644 --- a/kube/compose.go +++ b/kube/compose.go @@ -74,7 +74,7 @@ func NewComposeService() (compose.Service, error) { func (s *composeService) Up(ctx context.Context, project *types.Project, options compose.UpOptions) error { w := progress.ContextWriter(ctx) - eventName := "Convert to Helm charts" + eventName := "Convert Compose file to Helm charts" w.Event(progress.CreatingEvent(eventName)) chart, err := helm.GetChartInMemory(project) @@ -83,16 +83,31 @@ func (s *composeService) Up(ctx context.Context, project *types.Project, options } w.Event(progress.NewEvent(eventName, progress.Done, "")) - eventName = "Install Helm charts" - w.Event(progress.CreatingEvent(eventName)) + stack, err := s.sdk.Get(project.Name) + if err != nil || stack == nil { + // install stack + eventName = "Install Compose stack" + w.Event(progress.CreatingEvent(eventName)) - err = s.sdk.InstallChart(project.Name, chart, func(format string, v ...interface{}) { - message := fmt.Sprintf(format, v...) - w.Event(progress.NewEvent(eventName, progress.Done, message)) - }) + err = s.sdk.InstallChart(project.Name, chart, func(format string, v ...interface{}) { + message := fmt.Sprintf(format, v...) + w.Event(progress.NewEvent(eventName, progress.Done, message)) + }) + + } else { + //update stack + eventName = "Updating Compose stack" + w.Event(progress.CreatingEvent(eventName)) + + err = s.sdk.UpdateChart(project.Name, chart, func(format string, v ...interface{}) { + message := fmt.Sprintf(format, v...) + w.Event(progress.NewEvent(eventName, progress.Done, message)) + }) + } if err != nil { return err } + w.Event(progress.NewEvent(eventName, progress.Done, "")) return s.client.WaitForPodState(ctx, client.WaitForStatusOptions{ diff --git a/kube/helm/helm.go b/kube/helm/helm.go index a8eeb135..fd04f787 100644 --- a/kube/helm/helm.go +++ b/kube/helm/helm.go @@ -84,6 +84,19 @@ func (hc *Actions) InstallChart(name string, chart *chart.Chart, logger func(for return err } +// UpdateChart upgrades chart +func (hc *Actions) UpdateChart(name string, chart *chart.Chart, logger func(format string, v ...interface{})) error { + err := hc.initialize(logger) + if err != nil { + return err + } + + actUpgrade := action.NewUpgrade(hc.Config) + actUpgrade.Namespace = hc.Namespace + _, err = actUpgrade.Run(name, chart, map[string]interface{}{}) + return err +} + // Uninstall uninstall chart func (hc *Actions) Uninstall(name string, logger func(format string, v ...interface{})) error { err := hc.initialize(logger) From 7fd3c6f5cbe64cba7a22e71178a89cf46497bc5c Mon Sep 17 00:00:00 2001 From: aiordache Date: Thu, 22 Apr 2021 11:15:48 +0200 Subject: [PATCH 3/6] Port forwarding attempt Signed-off-by: aiordache --- kube/client/client.go | 41 +++++++++++++++++++++++++++++++++++++++++ kube/client/utils.go | 7 +++++++ kube/compose.go | 32 +++++++++++++++++++++++++++++++- 3 files changed, 79 insertions(+), 1 deletion(-) diff --git a/kube/client/client.go b/kube/client/client.go index 6c4d6eb0..0b9a241b 100644 --- a/kube/client/client.go +++ b/kube/client/client.go @@ -22,6 +22,8 @@ import ( "context" "fmt" "io" + "net/http" + "os" "time" "github.com/docker/compose-cli/api/compose" @@ -31,12 +33,16 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/cli-runtime/pkg/genericclioptions" "k8s.io/client-go/kubernetes" + "k8s.io/client-go/rest" + "k8s.io/client-go/tools/portforward" + "k8s.io/client-go/transport/spdy" ) // KubeClient API to access kube objects type KubeClient struct { client *kubernetes.Clientset namespace string + config *rest.Config } // NewKubeClient new kubernetes client @@ -59,6 +65,7 @@ func NewKubeClient(config genericclioptions.RESTClientGetter) (*KubeClient, erro return &KubeClient{ client: clientset, namespace: namespace, + config: restConfig, }, nil } @@ -161,3 +168,37 @@ func (kc KubeClient) WaitForPodState(ctx context.Context, opts WaitForStatusOpti } return nil } + +func (kc KubeClient) MapPorts(ctx context.Context, opts PortMappingOptions) error { + + stopChannel := make(chan struct{}, 1) + readyChannel := make(chan struct{}) + + eg, ctx := errgroup.WithContext(ctx) + for serviceName, servicePorts := range opts.Services { + serviceName = serviceName + servicePorts = servicePorts + eg.Go(func() error { + + req := kc.client.RESTClient().Post().Resource("services").Namespace(kc.namespace).Name(serviceName).SubResource("portforward") + transport, upgrader, err := spdy.RoundTripperFor(kc.config) + if err != nil { + return err + } + + ports := []string{} + for _, p := range servicePorts { + ports = append(ports, fmt.Sprintf("%d:%d", p.PublishedPort, p.TargetPort)) + } + //println(req.URL().String()) + //os.Exit(0) + dialer := spdy.NewDialer(upgrader, &http.Client{Transport: transport}, "POST", req.URL()) + fw, err := portforward.New(dialer, ports, stopChannel, readyChannel, os.Stdout, os.Stderr) + if err != nil { + return err + } + return fw.ForwardPorts() + }) + } + return eg.Wait() +} diff --git a/kube/client/utils.go b/kube/client/utils.go index 4368dc7a..c6d7ec64 100644 --- a/kube/client/utils.go +++ b/kube/client/utils.go @@ -98,3 +98,10 @@ type WaitForStatusOptions struct { Timeout *time.Duration Log LogFunc } + +type Ports []compose.PortPublisher + +type PortMappingOptions struct { + ProjectName string + Services map[string]Ports +} diff --git a/kube/compose.go b/kube/compose.go index d998915a..c3c5974d 100644 --- a/kube/compose.go +++ b/kube/compose.go @@ -110,7 +110,7 @@ func (s *composeService) Up(ctx context.Context, project *types.Project, options w.Event(progress.NewEvent(eventName, progress.Done, "")) - return s.client.WaitForPodState(ctx, client.WaitForStatusOptions{ + err = s.client.WaitForPodState(ctx, client.WaitForStatusOptions{ ProjectName: project.Name, Services: project.ServiceNames(), Status: compose.RUNNING, @@ -122,6 +122,36 @@ func (s *composeService) Up(ctx context.Context, project *types.Project, options w.Event(progress.NewEvent(pod, state, message)) }, }) + return err + /* + if err != nil { + return err + } + + // check if there is a port mapping + services := map[string]client.Ports{} + + for _, s := range project.Services { + if len(s.Ports) > 0 { + services[s.Name] = client.Ports{} + for _, p := range s.Ports { + services[s.Name] = append(services[s.Name], compose.PortPublisher{ + TargetPort: int(p.Target), + PublishedPort: int(p.Published), + Protocol: p.Protocol, + }) + } + } + } + if len(services) > 0 { + return s.client.MapPorts(ctx, client.PortMappingOptions{ + ProjectName: project.Name, + Services: services, + }) + } + return nil + */ + } // Down executes the equivalent to a `compose down` From d8db079af3c520274ae7456596c34b82c231a548 Mon Sep 17 00:00:00 2001 From: aiordache Date: Fri, 23 Apr 2021 12:54:51 +0200 Subject: [PATCH 4/6] Add exec command Signed-off-by: aiordache --- kube/client/client.go | 85 ++++++++++++++++++++++++++++++++++++++++++- kube/compose.go | 51 +++++++++++++------------- 2 files changed, 108 insertions(+), 28 deletions(-) diff --git a/kube/client/client.go b/kube/client/client.go index 0b9a241b..40f7ee73 100644 --- a/kube/client/client.go +++ b/kube/client/client.go @@ -31,10 +31,12 @@ import ( "golang.org/x/sync/errgroup" corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" "k8s.io/cli-runtime/pkg/genericclioptions" "k8s.io/client-go/kubernetes" "k8s.io/client-go/rest" "k8s.io/client-go/tools/portforward" + "k8s.io/client-go/tools/remotecommand" "k8s.io/client-go/transport/spdy" ) @@ -43,6 +45,7 @@ type KubeClient struct { client *kubernetes.Clientset namespace string config *rest.Config + ioStreams genericclioptions.IOStreams } // NewKubeClient new kubernetes client @@ -54,7 +57,7 @@ func NewKubeClient(config genericclioptions.RESTClientGetter) (*KubeClient, erro clientset, err := kubernetes.NewForConfig(restConfig) if err != nil { - return nil, err + return nil, fmt.Errorf("failed creating clientset. Error: %+v", err) } namespace, _, err := config.ToRawKubeConfigLoader().Namespace() @@ -66,9 +69,83 @@ func NewKubeClient(config genericclioptions.RESTClientGetter) (*KubeClient, erro client: clientset, namespace: namespace, config: restConfig, + ioStreams: genericclioptions.IOStreams{In: os.Stdin, Out: os.Stdout, ErrOut: os.Stderr}, }, nil } +// GetContainers get containers for a given compose project +func (kc KubeClient) GetPod(ctx context.Context, projectName, serviceName string) (*corev1.Pod, error) { + pods, err := kc.client.CoreV1().Pods(kc.namespace).List(ctx, metav1.ListOptions{ + LabelSelector: fmt.Sprintf("%s=%s", compose.ProjectTag, projectName), + }) + if err != nil { + return nil, err + } + if pods == nil { + return nil, nil + } + var pod corev1.Pod + for _, p := range pods.Items { + service := p.Labels[compose.ServiceTag] + if service == serviceName { + pod = p + break + } + } + return &pod, nil +} + +// Exec executes a command in a container +func (kc KubeClient) Exec(ctx context.Context, projectName string, opts compose.RunOptions) error { + pod, err := kc.GetPod(ctx, projectName, opts.Service) + if err != nil || pod == nil { + return err + } + if len(pod.Spec.Containers) == 0 { + return fmt.Errorf("no containers running in pod %s", pod.Name) + } + // get first container in the pod + container := &pod.Spec.Containers[0] + containerName := container.Name + + req := kc.client.CoreV1().RESTClient().Post(). + Resource("pods"). + Name(pod.Name). + Namespace(kc.namespace). + SubResource("exec") + + option := &corev1.PodExecOptions{ + Container: containerName, + Command: opts.Command, + Stdin: true, + Stdout: true, + Stderr: true, + TTY: opts.Tty, + } + + if opts.Reader == nil { + option.Stdin = false + } + + scheme := runtime.NewScheme() + if err := corev1.AddToScheme(scheme); err != nil { + return fmt.Errorf("error adding to scheme: %v", err) + } + parameterCodec := runtime.NewParameterCodec(scheme) + req.VersionedParams(option, parameterCodec) + + exec, err := remotecommand.NewSPDYExecutor(kc.config, "POST", req.URL()) + if err != nil { + return err + } + return exec.Stream(remotecommand.StreamOptions{ + Stdin: opts.Reader, + Stdout: opts.Writer, + Stderr: opts.Writer, + Tty: opts.Tty, + }) +} + // GetContainers get containers for a given compose project func (kc KubeClient) GetContainers(ctx context.Context, projectName string, all bool) ([]compose.ContainerSummary, error) { fieldSelector := "" @@ -178,9 +255,13 @@ func (kc KubeClient) MapPorts(ctx context.Context, opts PortMappingOptions) erro for serviceName, servicePorts := range opts.Services { serviceName = serviceName servicePorts = servicePorts + pod, err := kc.GetPod(ctx, opts.ProjectName, serviceName) + if err != nil { + return err + } eg.Go(func() error { - req := kc.client.RESTClient().Post().Resource("services").Namespace(kc.namespace).Name(serviceName).SubResource("portforward") + req := kc.client.RESTClient().Post().Resource("pods").Namespace(kc.namespace).Name(pod.Name).SubResource("portforward") //fmt.Sprintf("service/%s", serviceName)).SubResource("portforward") transport, upgrader, err := spdy.RoundTripperFor(kc.config) if err != nil { return err diff --git a/kube/compose.go b/kube/compose.go index c3c5974d..61fe57e3 100644 --- a/kube/compose.go +++ b/kube/compose.go @@ -122,35 +122,34 @@ func (s *composeService) Up(ctx context.Context, project *types.Project, options w.Event(progress.NewEvent(pod, state, message)) }, }) - return err - /* - if err != nil { - return err - } + //return err - // check if there is a port mapping - services := map[string]client.Ports{} + if err != nil { + return err + } - for _, s := range project.Services { - if len(s.Ports) > 0 { - services[s.Name] = client.Ports{} - for _, p := range s.Ports { - services[s.Name] = append(services[s.Name], compose.PortPublisher{ - TargetPort: int(p.Target), - PublishedPort: int(p.Published), - Protocol: p.Protocol, - }) - } + // check if there is a port mapping + services := map[string]client.Ports{} + + for _, s := range project.Services { + if len(s.Ports) > 0 { + services[s.Name] = client.Ports{} + for _, p := range s.Ports { + services[s.Name] = append(services[s.Name], compose.PortPublisher{ + TargetPort: int(p.Target), + PublishedPort: int(p.Published), + Protocol: p.Protocol, + }) } } - if len(services) > 0 { - return s.client.MapPorts(ctx, client.PortMappingOptions{ - ProjectName: project.Name, - Services: services, - }) - } - return nil - */ + } + if len(services) > 0 { + return s.client.MapPorts(ctx, client.PortMappingOptions{ + ProjectName: project.Name, + Services: services, + }) + } + return nil } @@ -311,7 +310,7 @@ func (s *composeService) Remove(ctx context.Context, project *types.Project, opt // Exec executes a command in a running service container func (s *composeService) Exec(ctx context.Context, project *types.Project, opts compose.RunOptions) (int, error) { - return 0, errdefs.ErrNotImplemented + return 0, s.client.Exec(ctx, project.Name, opts) } func (s *composeService) Pause(ctx context.Context, project string, options compose.PauseOptions) error { From 5d9d39dabd8e4b49a34a7f76027c81cb57a866c8 Mon Sep 17 00:00:00 2001 From: aiordache Date: Mon, 26 Apr 2021 11:47:35 +0200 Subject: [PATCH 5/6] Add port-forwarding on `compose up` Signed-off-by: aiordache --- kube/client/client.go | 23 ++++++++++++----------- kube/compose.go | 5 +---- 2 files changed, 13 insertions(+), 15 deletions(-) diff --git a/kube/client/client.go b/kube/client/client.go index 40f7ee73..24b115b6 100644 --- a/kube/client/client.go +++ b/kube/client/client.go @@ -246,8 +246,8 @@ func (kc KubeClient) WaitForPodState(ctx context.Context, opts WaitForStatusOpti return nil } -func (kc KubeClient) MapPorts(ctx context.Context, opts PortMappingOptions) error { - +//MapPortsToLocalhost runs a port-forwarder daemon process +func (kc KubeClient) MapPortsToLocalhost(ctx context.Context, opts PortMappingOptions) error { stopChannel := make(chan struct{}, 1) readyChannel := make(chan struct{}) @@ -260,19 +260,20 @@ func (kc KubeClient) MapPorts(ctx context.Context, opts PortMappingOptions) erro return err } eg.Go(func() error { - - req := kc.client.RESTClient().Post().Resource("pods").Namespace(kc.namespace).Name(pod.Name).SubResource("portforward") //fmt.Sprintf("service/%s", serviceName)).SubResource("portforward") - transport, upgrader, err := spdy.RoundTripperFor(kc.config) - if err != nil { - return err - } - ports := []string{} for _, p := range servicePorts { ports = append(ports, fmt.Sprintf("%d:%d", p.PublishedPort, p.TargetPort)) } - //println(req.URL().String()) - //os.Exit(0) + + req := kc.client.CoreV1().RESTClient().Post(). + Resource("pods"). + Name(pod.Name). + Namespace(kc.namespace). + SubResource("portforward") + transport, upgrader, err := spdy.RoundTripperFor(kc.config) + if err != nil { + return err + } dialer := spdy.NewDialer(upgrader, &http.Client{Transport: transport}, "POST", req.URL()) fw, err := portforward.New(dialer, ports, stopChannel, readyChannel, os.Stdout, os.Stderr) if err != nil { diff --git a/kube/compose.go b/kube/compose.go index 61fe57e3..a4a12430 100644 --- a/kube/compose.go +++ b/kube/compose.go @@ -122,15 +122,12 @@ func (s *composeService) Up(ctx context.Context, project *types.Project, options w.Event(progress.NewEvent(pod, state, message)) }, }) - //return err - if err != nil { return err } // check if there is a port mapping services := map[string]client.Ports{} - for _, s := range project.Services { if len(s.Ports) > 0 { services[s.Name] = client.Ports{} @@ -144,7 +141,7 @@ func (s *composeService) Up(ctx context.Context, project *types.Project, options } } if len(services) > 0 { - return s.client.MapPorts(ctx, client.PortMappingOptions{ + return s.client.MapPortsToLocalhost(ctx, client.PortMappingOptions{ ProjectName: project.Name, Services: services, }) From 0d25709ada13b6850cacef4aad21ab0850cf3e43 Mon Sep 17 00:00:00 2001 From: aiordache Date: Tue, 27 Apr 2021 09:55:43 +0200 Subject: [PATCH 6/6] Add port mapping to `compose ps` Signed-off-by: aiordache --- kube/client/client.go | 39 +++++++++++++++++++++++++++++++++++---- kube/client/utils.go | 2 ++ kube/compose.go | 28 +--------------------------- kube/resources/kube.go | 4 ++-- 4 files changed, 40 insertions(+), 33 deletions(-) diff --git a/kube/client/client.go b/kube/client/client.go index 24b115b6..8d8eb589 100644 --- a/kube/client/client.go +++ b/kube/client/client.go @@ -24,6 +24,7 @@ import ( "io" "net/http" "os" + "strings" "time" "github.com/docker/compose-cli/api/compose" @@ -73,7 +74,7 @@ func NewKubeClient(config genericclioptions.RESTClientGetter) (*KubeClient, erro }, nil } -// GetContainers get containers for a given compose project +// GetPod retrieves a service pod func (kc KubeClient) GetPod(ctx context.Context, projectName, serviceName string) (*corev1.Pod, error) { pods, err := kc.client.CoreV1().Pods(kc.namespace).List(ctx, metav1.ListOptions{ LabelSelector: fmt.Sprintf("%s=%s", compose.ProjectTag, projectName), @@ -160,9 +161,39 @@ func (kc KubeClient) GetContainers(ctx context.Context, projectName string, all if err != nil { return nil, err } + services := map[string][]compose.PortPublisher{} result := []compose.ContainerSummary{} for _, pod := range pods.Items { - result = append(result, podToContainerSummary(pod)) + summary := podToContainerSummary(pod) + serviceName := pod.GetObjectMeta().GetLabels()[compose.ServiceTag] + ports, ok := services[serviceName] + if !ok { + s, err := kc.client.CoreV1().Services(kc.namespace).Get(ctx, serviceName, metav1.GetOptions{}) + if err != nil { + if !strings.Contains(err.Error(), "not found") { + return nil, err + } + result = append(result, summary) + continue + } + ports = []compose.PortPublisher{} + if s != nil { + if s.Spec.Type == corev1.ServiceTypeLoadBalancer { + if len(s.Status.LoadBalancer.Ingress) > 0 { + port := compose.PortPublisher{URL: s.Status.LoadBalancer.Ingress[0].IP} + if len(s.Spec.Ports) > 0 { + port.URL = fmt.Sprintf("%s:%d", port.URL, s.Spec.Ports[0].Port) + port.TargetPort = s.Spec.Ports[0].TargetPort.IntValue() + port.Protocol = string(s.Spec.Ports[0].Protocol) + } + ports = append(ports, port) + } + } + } + services[serviceName] = ports + } + summary.Publishers = ports + result = append(result, summary) } return result, nil @@ -253,8 +284,8 @@ func (kc KubeClient) MapPortsToLocalhost(ctx context.Context, opts PortMappingOp eg, ctx := errgroup.WithContext(ctx) for serviceName, servicePorts := range opts.Services { - serviceName = serviceName - servicePorts = servicePorts + serviceName := serviceName + servicePorts := servicePorts pod, err := kc.GetPod(ctx, opts.ProjectName, serviceName) if err != nil { return err diff --git a/kube/client/utils.go b/kube/client/utils.go index c6d7ec64..e93e087b 100644 --- a/kube/client/utils.go +++ b/kube/client/utils.go @@ -99,8 +99,10 @@ type WaitForStatusOptions struct { Log LogFunc } +// Ports holds published ports data type Ports []compose.PortPublisher +// PortMappingOptions holds the port mapping for project services type PortMappingOptions struct { ProjectName string Services map[string]Ports diff --git a/kube/compose.go b/kube/compose.go index a4a12430..7b4e9133 100644 --- a/kube/compose.go +++ b/kube/compose.go @@ -110,7 +110,7 @@ func (s *composeService) Up(ctx context.Context, project *types.Project, options w.Event(progress.NewEvent(eventName, progress.Done, "")) - err = s.client.WaitForPodState(ctx, client.WaitForStatusOptions{ + return s.client.WaitForPodState(ctx, client.WaitForStatusOptions{ ProjectName: project.Name, Services: project.ServiceNames(), Status: compose.RUNNING, @@ -122,32 +122,6 @@ func (s *composeService) Up(ctx context.Context, project *types.Project, options w.Event(progress.NewEvent(pod, state, message)) }, }) - if err != nil { - return err - } - - // check if there is a port mapping - services := map[string]client.Ports{} - for _, s := range project.Services { - if len(s.Ports) > 0 { - services[s.Name] = client.Ports{} - for _, p := range s.Ports { - services[s.Name] = append(services[s.Name], compose.PortPublisher{ - TargetPort: int(p.Target), - PublishedPort: int(p.Published), - Protocol: p.Protocol, - }) - } - } - } - if len(services) > 0 { - return s.client.MapPortsToLocalhost(ctx, client.PortMappingOptions{ - ProjectName: project.Name, - Services: services, - }) - } - return nil - } // Down executes the equivalent to a `compose down` diff --git a/kube/resources/kube.go b/kube/resources/kube.go index 214e9d13..bbbe6b35 100644 --- a/kube/resources/kube.go +++ b/kube/resources/kube.go @@ -94,8 +94,8 @@ func mapToService(project *types.Project, service types.ServiceConfig) *core.Ser } ports = append(ports, core.ServicePort{ - Name: fmt.Sprintf("%d-%s", p.Target, strings.ToLower(p.Protocol)), - Port: int32(p.Target), + Name: fmt.Sprintf("%d-%s", p.Published, strings.ToLower(p.Protocol)), + Port: int32(p.Published), TargetPort: intstr.FromInt(int(p.Target)), Protocol: toProtocol(p.Protocol), })