gitee.com/liuxuezhan/go-micro-v1.18.0@v1.0.0/runtime/kubernetes/service.go (about)

     1  package kubernetes
     2  
     3  import (
     4  	"strings"
     5  	"time"
     6  
     7  	"gitee.com/liuxuezhan/go-micro-v1.18.0/runtime"
     8  	"gitee.com/liuxuezhan/go-micro-v1.18.0/runtime/kubernetes/client"
     9  	"gitee.com/liuxuezhan/go-micro-v1.18.0/util/log"
    10  )
    11  
    12  type service struct {
    13  	// service to manage
    14  	*runtime.Service
    15  	// Kubernetes service
    16  	kservice *client.Service
    17  	// Kubernetes deployment
    18  	kdeploy *client.Deployment
    19  }
    20  
    21  func newService(s *runtime.Service, c runtime.CreateOptions) *service {
    22  	// use pre-formatted name/version
    23  	name := client.Format(s.Name)
    24  	version := client.Format(s.Version)
    25  
    26  	kservice := client.NewService(name, version, c.Type)
    27  	kdeploy := client.NewDeployment(name, version, c.Type)
    28  
    29  	// attach our values to the deployment; name, version, source
    30  	kdeploy.Metadata.Annotations["name"] = s.Name
    31  	kdeploy.Metadata.Annotations["version"] = s.Version
    32  	kdeploy.Metadata.Annotations["source"] = s.Source
    33  
    34  	// associate owner:group to be later augmented
    35  	kdeploy.Metadata.Annotations["owner"] = "micro"
    36  	kdeploy.Metadata.Annotations["group"] = "micro"
    37  
    38  	// set a build timestamp to the current time
    39  	if kdeploy.Spec.Template.Metadata.Annotations == nil {
    40  		kdeploy.Spec.Template.Metadata.Annotations = make(map[string]string)
    41  	}
    42  	kdeploy.Spec.Template.Metadata.Annotations["build"] = time.Now().Format(time.RFC3339)
    43  
    44  	// define the environment values used by the container
    45  	env := make([]client.EnvVar, 0, len(c.Env))
    46  	for _, evar := range c.Env {
    47  		evarPair := strings.Split(evar, "=")
    48  		env = append(env, client.EnvVar{Name: evarPair[0], Value: evarPair[1]})
    49  	}
    50  
    51  	// if environment has been supplied update deployment default environment
    52  	if len(env) > 0 {
    53  		kdeploy.Spec.Template.PodSpec.Containers[0].Env = append(kdeploy.Spec.Template.PodSpec.Containers[0].Env, env...)
    54  	}
    55  
    56  	// specify the command to exec
    57  	if len(c.Command) > 0 {
    58  		kdeploy.Spec.Template.PodSpec.Containers[0].Command = c.Command
    59  	} else if len(s.Source) > 0 {
    60  		// default command for our k8s service should be source
    61  		kdeploy.Spec.Template.PodSpec.Containers[0].Command = []string{"go", "run", s.Source}
    62  	}
    63  
    64  	return &service{
    65  		Service:  s,
    66  		kservice: kservice,
    67  		kdeploy:  kdeploy,
    68  	}
    69  }
    70  
    71  func deploymentResource(d *client.Deployment) *client.Resource {
    72  	return &client.Resource{
    73  		Name:  d.Metadata.Name,
    74  		Kind:  "deployment",
    75  		Value: d,
    76  	}
    77  }
    78  
    79  func serviceResource(s *client.Service) *client.Resource {
    80  	return &client.Resource{
    81  		Name:  s.Metadata.Name,
    82  		Kind:  "service",
    83  		Value: s,
    84  	}
    85  }
    86  
    87  // Start starts the Kubernetes service. It creates new kubernetes deployment and service API objects
    88  func (s *service) Start(k client.Kubernetes) error {
    89  	// create deployment first; if we fail, we dont create service
    90  	if err := k.Create(deploymentResource(s.kdeploy)); err != nil {
    91  		log.Debugf("Runtime failed to create deployment: %v", err)
    92  		return err
    93  	}
    94  	// create service now that the deployment has been created
    95  	if err := k.Create(serviceResource(s.kservice)); err != nil {
    96  		log.Debugf("Runtime failed to create service: %v", err)
    97  		return err
    98  	}
    99  
   100  	return nil
   101  }
   102  
   103  func (s *service) Stop(k client.Kubernetes) error {
   104  	// first attempt to delete service
   105  	if err := k.Delete(serviceResource(s.kservice)); err != nil {
   106  		log.Debugf("Runtime failed to delete service: %v", err)
   107  		return err
   108  	}
   109  	// delete deployment once the service has been deleted
   110  	if err := k.Delete(deploymentResource(s.kdeploy)); err != nil {
   111  		log.Debugf("Runtime failed to delete deployment: %v", err)
   112  		return err
   113  	}
   114  
   115  	return nil
   116  }
   117  
   118  func (s *service) Update(k client.Kubernetes) error {
   119  	if err := k.Update(deploymentResource(s.kdeploy)); err != nil {
   120  		log.Debugf("Runtime failed to update deployment: %v", err)
   121  		return err
   122  	}
   123  	if err := k.Update(serviceResource(s.kservice)); err != nil {
   124  		log.Debugf("Runtime failed to update service: %v", err)
   125  		return err
   126  	}
   127  
   128  	return nil
   129  }