Merge pull request #2 from att-cloudnative-labs/knative-service-configure

Knative service configure

Author: gbraxton

CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## Development release
 
+0.7.0-BETA-1
+
+- KconfigBindings renamed to DeploymentBinding
+- Support for StatefulSets with an accompanying resource StatefulSetBinding
+- Support for Knative Services with an accompanying resource KnativeServiceBinding
+- Pkg names are now aligned with github location
+- Binary and k8s resources renamed from kconfig-controller-manager to kconfig-controller
+
 0.6.0-BETA-1
 
 - ExternalResources (ConfigMaps/Secrets) are now updated in one kubernetes api call per resource. Previously, multiple value changes (or adds) would result in an attempt to update the secret or configmap for each change. This would create a conflict error forcing the remaining values to be updated in retries.

Makefile

@@ -1,12 +1,12 @@
 # Go parameters
-VERSION=v0.6.0-beta-1
-DOCKERIMAGE=docker-registry.aeg.cloud/common-system/kconfig-controller
+VERSION=v0.7.0-beta-1
+DOCKERIMAGE=docker-registry.aeg.cloud/kconfig-system/kconfig-controller
 GOCMD=go
 GOBUILD=$(GOCMD) build
 GOCLEAN=$(GOCMD) clean
 GOTEST=$(GOCMD) test
 GOGET=$(GOCMD) get
-KCONFIGPKG=github.com/gbraxton/kconfig/cmd
+KCONFIGPKG=github.com/att-cloudnative-labs/kconfig-controller/cmd
 CLIENTSET=pkg/client/clientset/versioned/clientset.go
 BINARY_NAME=kconfig-controller
 BINARY_UNIX=$(BINARY_NAME)_unix

README.md

@@ -2,15 +2,15 @@
 
 ----
 
-Kconfig is a Kubernetes Custom-controller and CRD for externalizing configuration of Kubernetes deployments. Kconfig allows environment variables to be defined in a single resource that selects deployments based on labels, and inserts the specified environment variables into the deployment.
+Kconfig is a Kubernetes Custom-controller and CRD for externalizing configuration of Kubernetes deployments, statefulsets, and knative services. Kconfig allows environment variables to be defined in a single resource that selects the target workload resource based on labels, and inserts the specified environment variables into the target workload resource.
 
-Multiple Kconfig resources can select a single deployment and the deployment will have the aggregation of each of those Kconfigs. In addition, Kconfigs have a level field which determines the order, in relation to other Kconfigs that select the same deployment, in which enviroment variables from multiple Kconfigs are defined in the container environment.
+Multiple Kconfig resources can select a single target resource and the target will have the aggregation of each of those Kconfigs. In addition, Kconfigs have a level field which determines the order, in relation to other Kconfigs that select the same target resource, in which environment variables from multiple Kconfigs are defined in the container environment.
 
 Aside from defining simple key/value pairs, Kconfigs can also define and reference environment variables to be stored in configmaps and/or secrets.
 
-For a deployment to have its environment variables controlled by Kconfigs, it needs the annotation ```kconfigcontroller.atteg.com/env=true```.
+For a target to have its environment variables controlled by Kconfigs, it needs the annotation ```kconfigcontroller.atteg.com/env=true```.
 
-Kconfigs have a secondary resource, KconfigBindings. These resources should not be created/manipulated directly by users and are used by the control loops. These KconfigBinding resources serve as a target for Kconfigs to update their changes whereafter, the controller can re-processed the contained enviroment variables for all Kconfigs that target a particular deployment. Note that there will always be one KconfigBinding for each Deployment that contains the kconfig enabled annotation shown above.
+Kconfig-controller also has secondary resources, DeploymentBindings, StatefulSetBindings, and KnativeServiceBindings. These resources should not be created/manipulated directly by users and are used by the control loops. These resources serve as a target for Kconfigs to update their changes whereafter, the controller can re-processed the contained environment variables for all Kconfigs that target a particular deployment, statefulset, or knative service. Note that there will always be one of these 'binding resources for each workload resource that contains the kconfig enabled annotation shown above.
 
 ----
 
@@ -61,7 +61,7 @@ The first envConfig is a 'Value' type. An empty type field implies a 'Value' typ
 ## Build
 
 ```bash
-docker build -f build/Dockerfile -t docker-registry.aeg.cloud/common-system/kconfig-controller:v0.6.0-beta-1 .
+docker build -f build/Dockerfile -t docker-registry.aeg.cloud/kconfig-system/kconfig-controller:v0.7.0-beta-1 .
 ```
 
 ## Installation
@@ -75,5 +75,4 @@ kubectl apply -f install/
 * Ability to select the container configs apply to. Currently the configs are only placed in the first container in a pod template
 * Validate that all existing configmap/secret references in a Kconfig exists and if not, removed them from the Kconfig
 * Support for files form and mount locations for files through Kconfigs
-* Possible move to injecting the environment variables directly to pods through a custom admission controller
-* Support for configuring Statefulsets
+* Possible move to injecting the environment variables directly to pods through a custom admission controller

build/Dockerfile

@@ -1,15 +1,15 @@
-FROM docker.io/golang:1.11 as buildimage
+FROM docker.io/golang:1.12.4 as buildimage
 
-COPY cmd $GOPATH/src/github.com/gbraxton/kconfig/cmd
-COPY internal $GOPATH/src/github.com/gbraxton/kconfig/internal
-COPY pkg $GOPATH/src/github.com/gbraxton/kconfig/pkg
-COPY vendor $GOPATH/src/github.com/gbraxton/kconfig/vendor
-WORKDIR $GOPATH/src/github.com/gbraxton/kconfig/
+COPY cmd $GOPATH/src/github.com/att-cloudnative-labs/kconfig-controller/cmd
+COPY internal $GOPATH/src/github.com/att-cloudnative-labs/kconfig-controller/internal
+COPY pkg $GOPATH/src/github.com/att-cloudnative-labs/kconfig-controller/pkg
+COPY go.mod $GOPATH/src/github.com/att-cloudnative-labs/kconfig-controller/go.mod
+COPY go.sum $GOPATH/src/github.com/att-cloudnative-labs/kconfig-controller/go.sum
+WORKDIR $GOPATH/src/github.com/att-cloudnative-labs/kconfig-controller
 
 # minimal passwd file is created for user in scratch image
 # Empty file is needed to create /tmp directory in scratch image
-RUN go get -d -v ./... && \
-    CGO_ENABLED=0 go build -o /go/bin/kconfig-controller github.com/gbraxton/kconfig/cmd && \
+RUN GO111MODULE=on CGO_ENABLED=0 go build -o /go/bin/kconfig-controller ./cmd && \
     echo "kconfig:x:1001:1001::/:" > /tmp/passwd.minimal && \
     touch /tmp/.empty
 

cmd/kconfig-controller-manager/app/controllermanager.go

@@ -0,0 +1,176 @@
+package app
+
+import (
+	"k8s.io/client-go/rest"
+	"time"
+
+	"github.com/spf13/cobra"
+
+	"github.com/att-cloudnative-labs/kconfig-controller/internal/app/kconfig-controller/controller/deployment"
+	"github.com/att-cloudnative-labs/kconfig-controller/internal/app/kconfig-controller/controller/deploymentbinding"
+	"github.com/att-cloudnative-labs/kconfig-controller/internal/app/kconfig-controller/controller/kconfig"
+	"github.com/att-cloudnative-labs/kconfig-controller/internal/app/kconfig-controller/controller/knativeservice"
+	"github.com/att-cloudnative-labs/kconfig-controller/internal/app/kconfig-controller/controller/knativeservicebinding"
+	"github.com/att-cloudnative-labs/kconfig-controller/internal/app/kconfig-controller/controller/statefulset"
+	"github.com/att-cloudnative-labs/kconfig-controller/internal/app/kconfig-controller/controller/statefulsetbinding"
+	"github.com/att-cloudnative-labs/kconfig-controller/internal/app/kconfig-controller/server"
+	clientset "github.com/att-cloudnative-labs/kconfig-controller/pkg/client/clientset/versioned"
+	knclientset "github.com/knative/serving/pkg/client/clientset/versioned"
+
+	// _ "github.com/att-cloudnative-labs/kconfig-controller/pkg/client/clientset/versioned/scheme"
+	informers "github.com/att-cloudnative-labs/kconfig-controller/pkg/client/informers/externalversions"
+	kninformers "github.com/knative/serving/pkg/client/informers/externalversions"
+	kubeinformers "k8s.io/client-go/informers"
+	"k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/tools/clientcmd"
+	"k8s.io/klog"
+	"k8s.io/sample-controller/pkg/signals"
+)
+
+// NewControllerManagerCommand creates a *cobra.Command object with default parameters
+func NewControllerManagerCommand() *cobra.Command {
+	cmd := &cobra.Command{
+		Use: "kconfig-controller-manager",
+		Long: `The Kconfig controller-manager is a daemon controller that provides the
+functionality for enacting the state defined in a Kconfig and its associated
+resources.`,
+		Run: run,
+	}
+	cmd.Flags().String("master", "", "apiserver url")
+	cmd.Flags().String("kubeconfig", "", "location of kubeconfig")
+	return cmd
+}
+
+func run(cmd *cobra.Command, args []string) {
+
+	masterURL, _ := cmd.Flags().GetString("master")
+	kubeconfig, _ := cmd.Flags().GetString("kubeconfig")
+	knativeServicesEnabled, _ := cmd.Flags().GetBool("knative")
+
+	// set up signals so we handle the first shutdown signal gracefully
+	stopCh := signals.SetupSignalHandler()
+
+	cfg, err := clientcmd.BuildConfigFromFlags(masterURL, kubeconfig)
+	if err != nil {
+		klog.Fatalf("Error building kubeconfig: %s", err.Error())
+	}
+
+	stdClient, err := kubernetes.NewForConfig(cfg)
+	if err != nil {
+		klog.Fatalf("Error building kubernetes clientset: %s", err.Error())
+	}
+
+	kconfigClient, err := clientset.NewForConfig(cfg)
+	if err != nil {
+		klog.Fatalf("Error building kconfig clientset: %s", err.Error())
+	}
+
+
+
+	stdInformerFactory := kubeinformers.NewSharedInformerFactory(stdClient, time.Second*30)
+	kconfigInformerFactory := informers.NewSharedInformerFactory(kconfigClient, time.Second*30)
+
+
+	deploymentBindingController := deploymentbinding.NewController(
+		stdClient,
+		kconfigClient,
+		stdInformerFactory.Core().V1().ConfigMaps(),
+		stdInformerFactory.Core().V1().Secrets(),
+		stdInformerFactory.Apps().V1().Deployments(),
+		kconfigInformerFactory.Kconfigcontroller().V1alpha1().DeploymentBindings(),
+	)
+
+	statefulSetBindingController := statefulsetbinding.NewController(
+		stdClient,
+		kconfigClient,
+		stdInformerFactory.Core().V1().ConfigMaps(),
+		stdInformerFactory.Core().V1().Secrets(),
+		stdInformerFactory.Apps().V1().StatefulSets(),
+		kconfigInformerFactory.Kconfigcontroller().V1alpha1().StatefulSetBindings(),
+	)
+
+
+
+	deploymentController := deployment.NewController(
+		stdClient,
+		kconfigClient,
+		stdInformerFactory.Apps().V1().Deployments(),
+		kconfigInformerFactory.Kconfigcontroller().V1alpha1().DeploymentBindings(),
+	)
+
+	statefulSetController := statefulset.NewController(
+		stdClient,
+		kconfigClient,
+		stdInformerFactory.Apps().V1().StatefulSets(),
+		kconfigInformerFactory.Kconfigcontroller().V1alpha1().StatefulSetBindings(),
+	)
+
+
+
+	kconfigController := kconfig.NewController(
+		stdClient,
+		kconfigClient,
+		stdInformerFactory.Core().V1().ConfigMaps(),
+		stdInformerFactory.Core().V1().Secrets(),
+		kconfigInformerFactory.Kconfigcontroller().V1alpha1().Kconfigs(),
+		kconfigInformerFactory.Kconfigcontroller().V1alpha1().DeploymentBindings(),
+		kconfigInformerFactory.Kconfigcontroller().V1alpha1().StatefulSetBindings(),
+		kconfigInformerFactory.Kconfigcontroller().V1alpha1().KnativeServiceBindings(),
+	)
+
+	go stdInformerFactory.Start(stopCh)
+	go kconfigInformerFactory.Start(stopCh)
+
+	if knativeServicesEnabled {
+		startKnativeControllers(cfg, stdClient, kconfigClient, stdInformerFactory, kconfigInformerFactory, stopCh)
+	}
+
+	go deploymentBindingController.Run(2, stopCh)
+	go statefulSetBindingController.Run(2, stopCh)
+
+
+	go deploymentController.Run(2, stopCh)
+	go statefulSetController.Run(2, stopCh)
+
+
+	go kconfigController.Run(2, stopCh)
+
+	serverCfg := server.Cfg{Port: 8080}
+	server := server.NewServer(serverCfg)
+	go server.Start()
+	defer server.Stop()
+
+	<-stopCh
+	klog.Infof("Shutting down main process")
+}
+
+func startKnativeControllers(cfg *rest.Config, stdClient kubernetes.Interface, kconfigClient clientset.Interface, stdInformerFactory kubeinformers.SharedInformerFactory, kconfigInformerFactory informers.SharedInformerFactory, stopCh <-chan struct{}) {
+	knativeClient, err := knclientset.NewForConfig(cfg)
+	if err != nil {
+		klog.Fatalf("Error building knative clientset: %s", err.Error())
+	}
+
+	knativeInformerFactory := kninformers.NewSharedInformerFactory(knativeClient, time.Second*30)
+
+	knativeServiceBindingController := knativeservicebinding.NewController(
+		stdClient,
+		kconfigClient,
+		knativeClient,
+		stdInformerFactory.Core().V1().ConfigMaps(),
+		stdInformerFactory.Core().V1().Secrets(),
+		knativeInformerFactory.Serving().V1alpha1().Services(),
+		kconfigInformerFactory.Kconfigcontroller().V1alpha1().KnativeServiceBindings(),
+	)
+	go knativeServiceBindingController.Run(2, stopCh)
+
+	knativeServiceController := knativeservice.NewController(
+		stdClient,
+		knativeClient,
+		kconfigClient,
+		knativeInformerFactory.Serving().V1alpha1().Services(),
+		kconfigInformerFactory.Kconfigcontroller().V1alpha1().KnativeServiceBindings(),
+	)
+	go knativeServiceController.Run(2, stopCh)
+
+	go knativeInformerFactory.Start(stopCh)
+}

cmd/kconfig-controller/app/kconfig-controller.go

@@ -9,7 +9,7 @@ import (
 
 	"k8s.io/klog"
 
-	"github.com/gbraxton/kconfig/cmd/kconfig-controller-manager/app"
+	"github.com/att-cloudnative-labs/kconfig-controller/cmd/kconfig-controller/app"
 )
 
 func main() {
@@ -20,6 +20,7 @@ func main() {
 
 	command := app.NewControllerManagerCommand()
 	command.Flags().AddGoFlagSet(goflag.CommandLine)
+	command.Flags().Bool("knative", false, "enable configuration of knative services")
 
 	if err := command.Execute(); err != nil {
 		fmt.Fprintf(os.Stderr, "%v\n", err)