Move runtime/kubernetes/client to util/kubernetes/client

util/kubernetes/client/api/api_test.go

@@ -0,0 +1,169 @@
+package api
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"reflect"
+	"testing"
+)
+
+type testcase struct {
+	Token  string
+	ReqFn  func(opts *Options) *Request
+	Method string
+	URI    string
+	Body   interface{}
+	Header map[string]string
+	Assert func(req *http.Request) bool
+}
+
+type assertFn func(req *http.Request) bool
+
+var tests = []testcase{
+	testcase{
+		ReqFn: func(opts *Options) *Request {
+			return NewRequest(opts).Get().Resource("service")
+		},
+		Method: "GET",
+		URI:    "/api/v1/namespaces/default/services/",
+	},
+	testcase{
+		ReqFn: func(opts *Options) *Request {
+			return NewRequest(opts).Get().Resource("service").Name("foo")
+		},
+		Method: "GET",
+		URI:    "/api/v1/namespaces/default/services/foo",
+	},
+	testcase{
+		ReqFn: func(opts *Options) *Request {
+			return NewRequest(opts).Get().Resource("service").Namespace("test").Name("bar")
+		},
+		Method: "GET",
+		URI:    "/api/v1/namespaces/test/services/bar",
+	},
+	testcase{
+		ReqFn: func(opts *Options) *Request {
+			return NewRequest(opts).Get().Resource("deployment").Name("foo")
+		},
+		Method: "GET",
+		URI:    "/apis/apps/v1/namespaces/default/deployments/foo",
+	},
+	testcase{
+		ReqFn: func(opts *Options) *Request {
+			return NewRequest(opts).Get().Resource("deployment").Namespace("test").Name("foo")
+		},
+		Method: "GET",
+		URI:    "/apis/apps/v1/namespaces/test/deployments/foo",
+	},
+	testcase{
+		ReqFn: func(opts *Options) *Request {
+			return NewRequest(opts).Get().Resource("pod").Params(&Params{LabelSelector: map[string]string{"foo": "bar"}})
+		},
+		Method: "GET",
+		URI:    "/api/v1/namespaces/default/pods/?labelSelector=foo%3Dbar",
+	},
+	testcase{
+		ReqFn: func(opts *Options) *Request {
+			return NewRequest(opts).Post().Resource("service").Name("foo").Body(map[string]string{"foo": "bar"})
+		},
+		Method: "POST",
+		URI:    "/api/v1/namespaces/default/services/foo",
+		Body:   map[string]string{"foo": "bar"},
+	},
+	testcase{
+		ReqFn: func(opts *Options) *Request {
+			return NewRequest(opts).Post().Resource("deployment").Namespace("test").Name("foo").Body(map[string]string{"foo": "bar"})
+		},
+		Method: "POST",
+		URI:    "/apis/apps/v1/namespaces/test/deployments/foo",
+		Body:   map[string]string{"foo": "bar"},
+	},
+	testcase{
+		ReqFn: func(opts *Options) *Request {
+			return NewRequest(opts).Put().Resource("endpoint").Name("baz").Body(map[string]string{"bam": "bar"})
+		},
+		Method: "PUT",
+		URI:    "/api/v1/namespaces/default/endpoints/baz",
+		Body:   map[string]string{"bam": "bar"},
+	},
+	testcase{
+		ReqFn: func(opts *Options) *Request {
+			return NewRequest(opts).Patch().Resource("endpoint").Name("baz").Body(map[string]string{"bam": "bar"})
+		},
+		Method: "PATCH",
+		URI:    "/api/v1/namespaces/default/endpoints/baz",
+		Body:   map[string]string{"bam": "bar"},
+	},
+	testcase{
+		ReqFn: func(opts *Options) *Request {
+			return NewRequest(opts).Patch().Resource("endpoint").Name("baz").SetHeader("foo", "bar")
+		},
+		Method: "PATCH",
+		URI:    "/api/v1/namespaces/default/endpoints/baz",
+		Header: map[string]string{"foo": "bar"},
+	},
+	testcase{
+		ReqFn: func(opts *Options) *Request {
+			return NewRequest(opts).Patch().Resource("deployment").Name("baz").SetHeader("foo", "bar")
+		},
+		Method: "PATCH",
+		URI:    "/apis/apps/v1/namespaces/default/deployments/baz",
+		Header: map[string]string{"foo": "bar"},
+	},
+}
+
+var wrappedHandler = func(test *testcase, t *testing.T) http.HandlerFunc {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		auth := r.Header.Get("Authorization")
+		if len(test.Token) > 0 && (len(auth) == 0 || auth != "Bearer "+test.Token) {
+			t.Errorf("test case token (%s) did not match expected token (%s)", "Bearer "+test.Token, auth)
+		}
+
+		if len(test.Method) > 0 && test.Method != r.Method {
+			t.Errorf("test case Method (%s) did not match expected Method (%s)", test.Method, r.Method)
+		}
+
+		if len(test.URI) > 0 && test.URI != r.URL.RequestURI() {
+			t.Errorf("test case URI (%s) did not match expected URI (%s)", test.URI, r.URL.RequestURI())
+		}
+
+		if test.Body != nil {
+			var res map[string]string
+			decoder := json.NewDecoder(r.Body)
+			if err := decoder.Decode(&res); err != nil {
+				t.Errorf("decoding body failed: %v", err)
+			}
+			if !reflect.DeepEqual(res, test.Body) {
+				t.Error("body did not match")
+			}
+		}
+
+		if test.Header != nil {
+			for k, v := range test.Header {
+				if r.Header.Get(k) != v {
+					t.Error("header did not exist")
+				}
+			}
+		}
+
+		w.WriteHeader(http.StatusOK)
+	})
+}
+
+func TestRequest(t *testing.T) {
+	for _, test := range tests {
+		ts := httptest.NewServer(wrappedHandler(&test, t))
+		req := test.ReqFn(&Options{
+			Host:        ts.URL,
+			Client:      &http.Client{},
+			BearerToken: &test.Token,
+			Namespace:   "default",
+		})
+		res := req.Do()
+		if res.Error() != nil {
+			t.Errorf("request failed with %v", res.Error())
+		}
+		ts.Close()
+	}
+}

util/kubernetes/client/api/request.go

@@ -0,0 +1,228 @@
+package api
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+
+	"github.com/micro/go-micro/util/log"
+)
+
+// Request is used to construct a http request for the k8s API.
+type Request struct {
+	client    *http.Client
+	header    http.Header
+	params    url.Values
+	method    string
+	host      string
+	namespace string
+
+	resource     string
+	resourceName *string
+	body         io.Reader
+
+	err error
+}
+
+// Params is the object to pass in to set paramaters
+// on a request.
+type Params struct {
+	LabelSelector map[string]string
+	Annotations   map[string]string
+}
+
+// verb sets method
+func (r *Request) verb(method string) *Request {
+	r.method = method
+	return r
+}
+
+// Get request
+func (r *Request) Get() *Request {
+	return r.verb("GET")
+}
+
+// Post request
+func (r *Request) Post() *Request {
+	return r.verb("POST")
+}
+
+// Put request
+func (r *Request) Put() *Request {
+	return r.verb("PUT")
+}
+
+// Patch request
+func (r *Request) Patch() *Request {
+	return r.verb("PATCH")
+}
+
+// Delete request
+func (r *Request) Delete() *Request {
+	return r.verb("DELETE")
+}
+
+// Namespace is to set the namespace to operate on
+func (r *Request) Namespace(s string) *Request {
+	r.namespace = s
+	return r
+}
+
+// Resource is the type of resource the operation is
+// for, such as "services", "endpoints" or "pods"
+func (r *Request) Resource(s string) *Request {
+	r.resource = s
+	return r
+}
+
+// Name is for targeting a specific resource by id
+func (r *Request) Name(s string) *Request {
+	r.resourceName = &s
+	return r
+}
+
+// Body pass in a body to set, this is for POST, PUT and PATCH requests
+func (r *Request) Body(in interface{}) *Request {
+	b := new(bytes.Buffer)
+	// if we're not sending YAML request, we encode to JSON
+	if r.header.Get("Content-Type") != "application/yaml" {
+		if err := json.NewEncoder(b).Encode(&in); err != nil {
+			r.err = err
+			return r
+		}
+		log.Debugf("Request body: %v", b)
+		r.body = b
+		return r
+	}
+
+	// if application/yaml is set, we assume we get a raw bytes so we just copy over
+	body, ok := in.(io.Reader)
+	if !ok {
+		r.err = errors.New("invalid data")
+		return r
+	}
+	// copy over data to the bytes buffer
+	if _, err := io.Copy(b, body); err != nil {
+		r.err = err
+		return r
+	}
+
+	log.Debugf("Request body: %v", b)
+	r.body = b
+	return r
+}
+
+// Params isused to set paramters on a request
+func (r *Request) Params(p *Params) *Request {
+	for k, v := range p.LabelSelector {
+		// create new key=value pair
+		value := fmt.Sprintf("%s=%s", k, v)
+		// check if there's an existing value
+		if label := r.params.Get("labelSelector"); len(label) > 0 {
+			value = fmt.Sprintf("%s,%s", label, value)
+		}
+		// set and overwrite the value
+		r.params.Set("labelSelector", value)
+	}
+
+	return r
+}
+
+// SetHeader sets a header on a request with
+// a `key` and `value`
+func (r *Request) SetHeader(key, value string) *Request {
+	r.header.Add(key, value)
+	return r
+}
+
+// request builds the http.Request from the options
+func (r *Request) request() (*http.Request, error) {
+	var url string
+	switch r.resource {
+	case "pod", "service", "endpoint":
+		// /api/v1/namespaces/{namespace}/pods
+		url = fmt.Sprintf("%s/api/v1/namespaces/%s/%ss/", r.host, r.namespace, r.resource)
+	case "deployment":
+		// /apis/apps/v1/namespaces/{namespace}/deployments/{name}
+		url = fmt.Sprintf("%s/apis/apps/v1/namespaces/%s/%ss/", r.host, r.namespace, r.resource)
+	}
+
+	// append resourceName if it is present
+	if r.resourceName != nil {
+		url += *r.resourceName
+	}
+
+	// append any query params
+	if len(r.params) > 0 {
+		url += "?" + r.params.Encode()
+	}
+
+	// build request
+	req, err := http.NewRequest(r.method, url, r.body)
+	if err != nil {
+		return nil, err
+	}
+
+	// set headers on request
+	req.Header = r.header
+	return req, nil
+}
+
+// Do builds and triggers the request
+func (r *Request) Do() *Response {
+	if r.err != nil {
+		return &Response{
+			err: r.err,
+		}
+	}
+
+	req, err := r.request()
+	if err != nil {
+		return &Response{
+			err: err,
+		}
+	}
+
+	log.Debugf("kubernetes api request: %v", req)
+
+	res, err := r.client.Do(req)
+	if err != nil {
+		return &Response{
+			err: err,
+		}
+	}
+
+	log.Debugf("kubernetes api response: %v", res)
+
+	// return res, err
+	return newResponse(res, err)
+}
+
+// Options ...
+type Options struct {
+	Host        string
+	Namespace   string
+	BearerToken *string
+	Client      *http.Client
+}
+
+// NewRequest creates a k8s api request
+func NewRequest(opts *Options) *Request {
+	req := &Request{
+		header:    make(http.Header),
+		params:    make(url.Values),
+		client:    opts.Client,
+		namespace: opts.Namespace,
+		host:      opts.Host,
+	}
+
+	if opts.BearerToken != nil {
+		req.SetHeader("Authorization", "Bearer "+*opts.BearerToken)
+	}
+
+	return req
+}

util/kubernetes/client/api/response.go

@@ -0,0 +1,95 @@
+package api
+
+import (
+	"encoding/json"
+	"errors"
+	"io/ioutil"
+	"net/http"
+
+	"github.com/micro/go-micro/util/log"
+)
+
+// Errors ...
+var (
+	ErrNotFound = errors.New("kubernetes: resource not found")
+	ErrDecode   = errors.New("kubernetes: error decoding")
+	ErrUnknown  = errors.New("kubernetes: unknown error")
+)
+
+// Status is an object that is returned when a request
+// failed or delete succeeded.
+// type Status struct {
+// 	Kind    string `json:"kind"`
+// 	Status  string `json:"status"`
+// 	Message string `json:"message"`
+// 	Reason  string `json:"reason"`
+// 	Code    int    `json:"code"`
+// }
+
+// Response ...
+type Response struct {
+	res *http.Response
+	err error
+
+	body []byte
+}
+
+// Error returns an error
+func (r *Response) Error() error {
+	return r.err
+}
+
+// StatusCode returns status code for response
+func (r *Response) StatusCode() int {
+	return r.res.StatusCode
+}
+
+// Into decode body into `data`
+func (r *Response) Into(data interface{}) error {
+	if r.err != nil {
+		return r.err
+	}
+
+	defer r.res.Body.Close()
+	decoder := json.NewDecoder(r.res.Body)
+	err := decoder.Decode(&data)
+	if err != nil {
+		return ErrDecode
+	}
+
+	return r.err
+}
+
+func newResponse(res *http.Response, err error) *Response {
+	r := &Response{
+		res: res,
+		err: err,
+	}
+
+	if err != nil {
+		return r
+	}
+
+	if r.res.StatusCode == http.StatusOK ||
+		r.res.StatusCode == http.StatusCreated ||
+		r.res.StatusCode == http.StatusNoContent {
+		// Non error status code
+		return r
+	}
+
+	if r.res.StatusCode == http.StatusNotFound {
+		r.err = ErrNotFound
+		return r
+	}
+
+	log.Logf("kubernetes: request failed with code %v", r.res.StatusCode)
+
+	b, err := ioutil.ReadAll(r.res.Body)
+	if err == nil {
+		log.Log("kubernetes: request failed with body:")
+		log.Log(string(b))
+	}
+	r.err = ErrUnknown
+
+	return r
+}

util/kubernetes/client/client.go

@@ -0,0 +1,155 @@
+package client
+
+import (
+	"bytes"
+	"crypto/tls"
+	"errors"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"path"
+
+	"github.com/micro/go-micro/util/kubernetes/client/api"
+	"github.com/micro/go-micro/util/log"
+)
+
+var (
+	// path to kubernetes service account token
+	serviceAccountPath = "/var/run/secrets/kubernetes.io/serviceaccount"
+	// ErrReadNamespace is returned when the names could not be read from service account
+	ErrReadNamespace = errors.New("Could not read namespace from service account secret")
+)
+
+// Client ...
+type client struct {
+	opts *api.Options
+}
+
+// NewClientInCluster creates a Kubernetes client for use from within a k8s pod.
+func NewClientInCluster() *client {
+	host := "https://" + os.Getenv("KUBERNETES_SERVICE_HOST") + ":" + os.Getenv("KUBERNETES_SERVICE_PORT")
+
+	s, err := os.Stat(serviceAccountPath)
+	if err != nil {
+		log.Fatal(err)
+	}
+	if s == nil || !s.IsDir() {
+		log.Fatal(errors.New("service account not found"))
+	}
+
+	token, err := ioutil.ReadFile(path.Join(serviceAccountPath, "token"))
+	if err != nil {
+		log.Fatal(err)
+	}
+	t := string(token)
+
+	ns, err := detectNamespace()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	crt, err := CertPoolFromFile(path.Join(serviceAccountPath, "ca.crt"))
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	c := &http.Client{
+		Transport: &http.Transport{
+			TLSClientConfig: &tls.Config{
+				RootCAs: crt,
+			},
+			DisableCompression: true,
+		},
+	}
+
+	return &client{
+		opts: &api.Options{
+			Client:      c,
+			Host:        host,
+			Namespace:   ns,
+			BearerToken: &t,
+		},
+	}
+}
+
+func detectNamespace() (string, error) {
+	nsPath := path.Join(serviceAccountPath, "namespace")
+
+	// Make sure it's a file and we can read it
+	if s, e := os.Stat(nsPath); e != nil {
+		return "", e
+	} else if s.IsDir() {
+		return "", ErrReadNamespace
+	}
+
+	// Read the file, and cast to a string
+	if ns, e := ioutil.ReadFile(nsPath); e != nil {
+		return string(ns), e
+	} else {
+		return string(ns), nil
+	}
+}
+
+// Create creates new API object
+func (c *client) Create(r *Resource) error {
+	b := new(bytes.Buffer)
+	if err := renderTemplate(r.Kind, b, r.Value); err != nil {
+		return err
+	}
+
+	return api.NewRequest(c.opts).
+		Post().
+		SetHeader("Content-Type", "application/yaml").
+		Resource(r.Kind).
+		Body(b).
+		Do().
+		Error()
+}
+
+// Get queries API objects and stores the result in r
+func (c *client) Get(r *Resource, labels map[string]string) error {
+	return api.NewRequest(c.opts).
+		Get().
+		Resource(r.Kind).
+		Params(&api.Params{LabelSelector: labels}).
+		Do().
+		Into(r.Value)
+}
+
+// Update updates API object
+func (c *client) Update(r *Resource) error {
+	req := api.NewRequest(c.opts).
+		Patch().
+		SetHeader("Content-Type", "application/strategic-merge-patch+json").
+		Resource(r.Kind).
+		Name(r.Name)
+
+	switch r.Kind {
+	case "service":
+		req.Body(r.Value.(*Service))
+	case "deployment":
+		req.Body(r.Value.(*Deployment))
+	default:
+		return errors.New("unsupported resource")
+	}
+
+	return req.Do().Error()
+}
+
+// Delete removes API object
+func (c *client) Delete(r *Resource) error {
+	return api.NewRequest(c.opts).
+		Delete().
+		Resource(r.Kind).
+		Name(r.Name).
+		Do().
+		Error()
+}
+
+// List lists API objects and stores the result in r
+func (c *client) List(r *Resource) error {
+	labels := map[string]string{
+		"micro": "service",
+	}
+	return c.Get(r, labels)
+}

util/kubernetes/client/kubernetes.go

@@ -0,0 +1,122 @@
+// Package client provides an implementation of a restricted subset of kubernetes API client
+package client
+
+import (
+	"strings"
+
+	"github.com/micro/go-micro/util/log"
+)
+
+var (
+	// DefaultImage is default micro image
+	DefaultImage = "micro/go-micro"
+)
+
+// Kubernetes client
+type Kubernetes interface {
+	// Create creates new API resource
+	Create(*Resource) error
+	// Get queries API resrouces
+	Get(*Resource, map[string]string) error
+	// Update patches existing API object
+	Update(*Resource) error
+	// Delete deletes API resource
+	Delete(*Resource) error
+	// List lists API resources
+	List(*Resource) error
+}
+
+// NewService returns default micro kubernetes service definition
+func NewService(name, version, typ string) *Service {
+	log.Tracef("kubernetes default service: name: %s, version: %s", name, version)
+
+	Labels := map[string]string{
+		"name":    name,
+		"version": version,
+		"micro":   typ,
+	}
+
+	svcName := name
+	if len(version) > 0 {
+		// API service object name joins name and version over "-"
+		svcName = strings.Join([]string{name, version}, "-")
+	}
+
+	Metadata := &Metadata{
+		Name:      svcName,
+		Namespace: "default",
+		Version:   version,
+		Labels:    Labels,
+	}
+
+	Spec := &ServiceSpec{
+		Type:     "ClusterIP",
+		Selector: Labels,
+		Ports: []ServicePort{{
+			"service-port", 9090, "",
+		}},
+	}
+
+	return &Service{
+		Metadata: Metadata,
+		Spec:     Spec,
+	}
+}
+
+// NewService returns default micro kubernetes deployment definition
+func NewDeployment(name, version, typ string) *Deployment {
+	log.Tracef("kubernetes default deployment: name: %s, version: %s", name, version)
+
+	Labels := map[string]string{
+		"name":    name,
+		"version": version,
+		"micro":   typ,
+	}
+
+	depName := name
+	if len(version) > 0 {
+		// API deployment object name joins name and version over "-"
+		depName = strings.Join([]string{name, version}, "-")
+	}
+
+	Metadata := &Metadata{
+		Name:        depName,
+		Namespace:   "default",
+		Version:     version,
+		Labels:      Labels,
+		Annotations: map[string]string{},
+	}
+
+	// enable go modules by default
+	env := EnvVar{
+		Name:  "GO111MODULE",
+		Value: "on",
+	}
+
+	Spec := &DeploymentSpec{
+		Replicas: 1,
+		Selector: &LabelSelector{
+			MatchLabels: Labels,
+		},
+		Template: &Template{
+			Metadata: Metadata,
+			PodSpec: &PodSpec{
+				Containers: []Container{{
+					Name:    name,
+					Image:   DefaultImage,
+					Env:     []EnvVar{env},
+					Command: []string{"go", "run", "main.go"},
+					Ports: []ContainerPort{{
+						Name:          "service-port",
+						ContainerPort: 8080,
+					}},
+				}},
+			},
+		},
+	}
+
+	return &Deployment{
+		Metadata: Metadata,
+		Spec:     Spec,
+	}
+}

util/kubernetes/client/templates.go

@@ -0,0 +1,105 @@
+package client
+
+var templates = map[string]string{
+	"deployment": deploymentTmpl,
+	"service":    serviceTmpl,
+}
+
+var deploymentTmpl = `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: "{{ .Metadata.Name }}"
+  namespace: "{{ .Metadata.Namespace }}"
+  labels:
+    {{- with .Metadata.Labels }}
+    {{- range $key, $value := . }}
+    {{ $key }}: "{{ $value }}"
+    {{- end }}
+    {{- end }}
+  annotations:
+    {{- with .Metadata.Annotations }}
+    {{- range $key, $value := . }}
+    {{ $key }}: "{{ $value }}"
+    {{- end }}
+    {{- end }}
+spec:
+  replicas: {{ .Spec.Replicas }}
+  selector:
+    matchLabels:
+      {{- with .Spec.Selector.MatchLabels }}
+      {{- range $key, $value := . }}
+      {{ $key }}: "{{ $value }}"
+      {{- end }}
+      {{- end }}
+  template:
+    metadata:
+      labels:
+        {{- with .Spec.Template.Metadata.Labels }}
+        {{- range $key, $value := . }}
+        {{ $key }}: "{{ $value }}"
+        {{- end }}
+        {{- end }}
+      annotations:
+        {{- with .Spec.Template.Metadata.Annotations }}
+        {{- range $key, $value := . }}
+        {{ $key }}: "{{ $value }}"
+        {{- end }}
+        {{- end }}
+    spec:
+      containers:
+      {{- with .Spec.Template.PodSpec.Containers }}
+      {{- range . }}
+        - name: {{ .Name }}
+          env:
+          {{- with .Env }}
+          {{- range . }}
+          - name: "{{ .Name }}"
+            value: "{{ .Value }}"
+          {{- end }}
+          {{- end }}
+          command:
+          {{- range .Command }}
+          - {{.}}
+          {{- end }}
+          image: {{ .Image }}
+          imagePullPolicy: Always
+          ports:
+          {{- with .Ports }}
+          {{- range . }}
+          - containerPort: {{ .ContainerPort }}
+            name: {{ .Name }}
+          {{- end}}
+          {{- end}}
+      {{- end }}
+      {{- end}}
+`
+
+var serviceTmpl = `
+apiVersion: v1
+kind: Service
+metadata:
+  name: "{{ .Metadata.Name }}"
+  namespace: "{{ .Metadata.Namespace }}"
+  labels:
+    {{- with .Metadata.Labels }}
+    {{- range $key, $value := . }}
+    {{ $key }}: "{{ $value }}"
+    {{- end }}
+    {{- end }}
+spec:
+  selector:
+    {{- with .Spec.Selector }}
+    {{- range $key, $value := . }}
+    {{ $key }}: "{{ $value }}"
+    {{- end }}
+    {{- end }}
+  ports:
+  {{- with .Spec.Ports }}
+  {{- range . }}
+  - name: "{{ .Name }}"
+    port: {{ .Port }}
+    protocol: {{ .Protocol }}
+  {{- end }}
+  {{- end }}
+`

util/kubernetes/client/types.go

@@ -0,0 +1,133 @@
+package client
+
+// Resource is API resource
+type Resource struct {
+	Name  string
+	Kind  string
+	Value interface{}
+}
+
+// Metadata defines api object metadata
+type Metadata struct {
+	Name        string            `json:"name,omitempty"`
+	Namespace   string            `json:"namespace,omitempty"`
+	Version     string            `json:"version,omitempty"`
+	Labels      map[string]string `json:"labels,omitempty"`
+	Annotations map[string]string `json:"annotations,omitempty"`
+}
+
+// ServicePort configures service ports
+type ServicePort struct {
+	Name     string `json:"name,omitempty"`
+	Port     int    `json:"port"`
+	Protocol string `json:"protocol,omitempty"`
+}
+
+// ServiceSpec provides service configuration
+type ServiceSpec struct {
+	Type     string            `json:"type,omitempty"`
+	Selector map[string]string `json:"selector,omitempty"`
+	Ports    []ServicePort     `json:"ports,omitempty"`
+}
+
+type LoadBalancerIngress struct {
+	IP       string `json:"ip,omitempty"`
+	Hostname string `json:"hostname,omitempty"`
+}
+
+type LoadBalancerStatus struct {
+	Ingress []LoadBalancerIngress `json:"ingress,omitempty"`
+}
+
+// ServiceStatus
+type ServiceStatus struct {
+	LoadBalancer LoadBalancerStatus `json:"loadBalancer,omitempty"`
+}
+
+// Service is kubernetes service
+type Service struct {
+	Metadata *Metadata      `json:"metadata"`
+	Spec     *ServiceSpec   `json:"spec,omitempty"`
+	Status   *ServiceStatus `json:"status,omitempty"`
+}
+
+// ServiceList
+type ServiceList struct {
+	Items []Service `json:"items"`
+}
+
+// ContainerPort
+type ContainerPort struct {
+	Name          string `json:"name,omitempty"`
+	HostPort      int    `json:"hostPort,omitempty"`
+	ContainerPort int    `json:"containerPort"`
+	Protocol      string `json:"protocol,omitempty"`
+}
+
+// EnvVar is environment variable
+type EnvVar struct {
+	Name  string `json:"name"`
+	Value string `json:"value,omitempty"`
+}
+
+// Container defined container runtime values
+type Container struct {
+	Name    string          `json:"name"`
+	Image   string          `json:"image"`
+	Env     []EnvVar        `json:"env,omitempty"`
+	Command []string        `json:"command,omitempty"`
+	Ports   []ContainerPort `json:"ports,omitempty"`
+}
+
+// PodSpec
+type PodSpec struct {
+	Containers []Container `json:"containers"`
+}
+
+// Template is micro deployment template
+type Template struct {
+	Metadata *Metadata `json:"metadata,omitempty"`
+	PodSpec  *PodSpec  `json:"spec,omitempty"`
+}
+
+// LabelSelector is a label query over a set of resources
+// NOTE: we do not support MatchExpressions at the moment
+type LabelSelector struct {
+	MatchLabels map[string]string `json:"matchLabels,omitempty"`
+}
+
+// DeploymentSpec defines micro deployment spec
+type DeploymentSpec struct {
+	Replicas int            `json:"replicas,omitempty"`
+	Selector *LabelSelector `json:"selector"`
+	Template *Template      `json:"template,omitempty"`
+}
+
+// DeploymentCondition describes the state of deployment
+type DeploymentCondition struct {
+	Type    string `json:"type"`
+	Reason  string `json:"reason,omitempty"`
+	Message string `json:"message,omitempty"`
+}
+
+// DeploymentStatus is returned when querying deployment
+type DeploymentStatus struct {
+	Replicas            int                   `json:"replicas,omitempty"`
+	UpdatedReplicas     int                   `json:"updatedReplicas,omitempty"`
+	ReadyReplicas       int                   `json:"readyReplicas,omitempty"`
+	AvailableReplicas   int                   `json:"availableReplicas,omitempty"`
+	UnavailableReplicas int                   `json:"unavailableReplicas,omitempty"`
+	Conditions          []DeploymentCondition `json:"conditions,omitempty"`
+}
+
+// Deployment is Kubernetes deployment
+type Deployment struct {
+	Metadata *Metadata         `json:"metadata"`
+	Spec     *DeploymentSpec   `json:"spec,omitempty"`
+	Status   *DeploymentStatus `json:"status,omitempty"`
+}
+
+// DeploymentList
+type DeploymentList struct {
+	Items []Deployment `json:"items"`
+}

util/kubernetes/client/util.go

@@ -0,0 +1,102 @@
+package client
+
+import (
+	"crypto/x509"
+	"encoding/pem"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"strings"
+	"text/template"
+)
+
+// renderTemplateFile renders template for a given resource into writer w
+func renderTemplate(resource string, w io.Writer, data interface{}) error {
+	t := template.Must(template.New("kubernetes").Parse(templates[resource]))
+
+	if err := t.Execute(w, data); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// COPIED FROM
+// https://github.com/kubernetes/kubernetes/blob/7a725418af4661067b56506faabc2d44c6d7703a/pkg/util/crypto/crypto.go
+
+// CertPoolFromFile returns an x509.CertPool containing the certificates in the given PEM-encoded file.
+// Returns an error if the file could not be read, a certificate could not be parsed, or if the file does not contain any certificates
+func CertPoolFromFile(filename string) (*x509.CertPool, error) {
+	certs, err := certificatesFromFile(filename)
+	if err != nil {
+		return nil, err
+	}
+	pool := x509.NewCertPool()
+	for _, cert := range certs {
+		pool.AddCert(cert)
+	}
+	return pool, nil
+}
+
+// certificatesFromFile returns the x509.Certificates contained in the given PEM-encoded file.
+// Returns an error if the file could not be read, a certificate could not be parsed, or if the file does not contain any certificates
+func certificatesFromFile(file string) ([]*x509.Certificate, error) {
+	if len(file) == 0 {
+		return nil, errors.New("error reading certificates from an empty filename")
+	}
+	pemBlock, err := ioutil.ReadFile(file)
+	if err != nil {
+		return nil, err
+	}
+	certs, err := CertsFromPEM(pemBlock)
+	if err != nil {
+		return nil, fmt.Errorf("error reading %s: %s", file, err)
+	}
+	return certs, nil
+}
+
+// CertsFromPEM returns the x509.Certificates contained in the given PEM-encoded byte array
+// Returns an error if a certificate could not be parsed, or if the data does not contain any certificates
+func CertsFromPEM(pemCerts []byte) ([]*x509.Certificate, error) {
+	ok := false
+	certs := []*x509.Certificate{}
+	for len(pemCerts) > 0 {
+		var block *pem.Block
+		block, pemCerts = pem.Decode(pemCerts)
+		if block == nil {
+			break
+		}
+		// Only use PEM "CERTIFICATE" blocks without extra headers
+		if block.Type != "CERTIFICATE" || len(block.Headers) != 0 {
+			continue
+		}
+
+		cert, err := x509.ParseCertificate(block.Bytes)
+		if err != nil {
+			return certs, err
+		}
+
+		certs = append(certs, cert)
+		ok = true
+	}
+
+	if !ok {
+		return certs, errors.New("could not read any certificates")
+	}
+	return certs, nil
+}
+
+// Format is used to format a string value into a k8s valid name
+func Format(v string) string {
+	// to lower case
+	v = strings.ToLower(v)
+	// dots to dashes
+	v = strings.ReplaceAll(v, ".", "-")
+	// limit to 253 chars
+	if len(v) > 253 {
+		v = v[:253]
+	}
+	// return new name
+	return v
+}

util/kubernetes/client/util_test.go

@@ -0,0 +1,46 @@
+package client
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestTemplates(t *testing.T) {
+	name := "foo"
+	version := "123"
+	typ := "service"
+
+	// Render default service
+	s := NewService(name, version, typ)
+	bs := new(bytes.Buffer)
+	if err := renderTemplate(templates["service"], bs, s); err != nil {
+		t.Errorf("Failed to render kubernetes service: %v", err)
+	}
+
+	// Render default deployment
+	d := NewDeployment(name, version, typ)
+	bd := new(bytes.Buffer)
+	if err := renderTemplate(templates["deployment"], bd, d); err != nil {
+		t.Errorf("Failed to render kubernetes deployment: %v", err)
+	}
+}
+
+func TestFormatName(t *testing.T) {
+	testCases := []struct {
+		name   string
+		expect string
+	}{
+		{"foobar", "foobar"},
+		{"foo-bar", "foo-bar"},
+		{"foo.bar", "foo-bar"},
+		{"Foo.Bar", "foo-bar"},
+		{"go.micro.foo.bar", "go-micro-foo-bar"},
+	}
+
+	for _, test := range testCases {
+		v := Format(test.name)
+		if v != test.expect {
+			t.Fatalf("Expected name %s for %s got: %s", test.expect, test.name, v)
+		}
+	}
+}