add | create kube resources from directory

Author: 0M1J

go-automation/kube_clients.go

@@ -0,0 +1,106 @@
+package goautomation
+
+import (
+	"context"
+	"encoding/base64"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
+
+	"golang.org/x/oauth2"
+	"golang.org/x/oauth2/google"
+	"google.golang.org/api/container/v1"
+	"google.golang.org/api/option"
+	"k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/rest"
+	"k8s.io/client-go/tools/clientcmd"
+)
+
+func GetGKEClinetset(cluster *container.Cluster, ts oauth2.TokenSource) (*kubernetes.Clientset, error) {
+    capem, err := base64.StdEncoding.DecodeString(cluster.MasterAuth.ClusterCaCertificate)
+    if err != nil {
+        return nil, fmt.Errorf("failed to decode cluster CA cert: %s", err)
+    }
+
+    config := &rest.Config{
+        Host: cluster.Endpoint,
+        TLSClientConfig: rest.TLSClientConfig{
+            CAData: capem,
+        },
+    }
+    config.Wrap(func(rt http.RoundTripper) http.RoundTripper {
+        return &oauth2.Transport{
+            Source: ts,
+            Base: rt,
+        }
+    }) 
+
+    clientset, err := kubernetes.NewForConfig(config)
+    if err != nil {
+        return nil, fmt.Errorf("failed to initialize clientset from config: %s", err) 
+    }
+    return clientset, nil
+}
+
+func GcpKubernetesSetup() (*kubernetes.Clientset, error){
+    gcpServiceAccountKeyFile := "gcp_service_account_key.json"
+    gkeLocation := "us-central1-c"
+    gkeClusterName := "kube-cluster"
+    // gkeNamespace := "default"
+
+    data, err := ioutil.ReadFile(gcpServiceAccountKeyFile)
+    if err != nil {
+        log.Fatalf("Failed to read GCP service account key file: %s", err)
+        return nil, err
+    }
+    ctx := context.Background()
+
+    creds, err := google.CredentialsFromJSON(ctx, data, container.CloudPlatformScope)
+    if err != nil {
+        log.Fatalf("Failed to load GCP service account credintials: %s", err)
+        return nil, err
+    }
+
+    gkeService, err := container.NewService(ctx, option.WithHTTPClient(oauth2.NewClient(ctx, creds.TokenSource)))
+    if err != nil {
+        log.Fatalf("Failed to initialize kubernetes engine service: %s", err)
+        return nil, err
+    }
+
+    name := fmt.Sprintf("projects/%s/locations/%s/clusters/%s", creds.ProjectID, gkeLocation, gkeClusterName)
+    cluster, err := container.NewProjectsLocationsClustersService(gkeService).Get(name).Do()
+    if err != nil {
+        log.Fatalf("Failed to load GKE cluster %q: %s", name, err)
+        return nil, err
+    }
+
+    clientset, err := GetGKEClinetset(cluster, creds.TokenSource)
+    if err != nil {
+        log.Fatalf("Failed to initialize kubernetes clientset: %s", err)
+        return nil, err
+    }
+
+    return clientset, nil
+}
+
+func LocalKubernetesSetup() (*kubernetes.Clientset, error) {
+    // load kubeconfig from the default config file 
+    kubeConfigPath := clientcmd.RecommendedHomeFile
+
+    // build config from config path
+    config, err := clientcmd.BuildConfigFromFlags("", kubeConfigPath)
+    if err != nil {
+        panic(err.Error())
+    }
+
+    // create a kubernetes clientset
+    clientset, err := kubernetes.NewForConfig(config)
+    if err != nil {
+        panic(err.Error())
+    }
+
+    return clientset, nil
+}
+
+

go-automation/kube_operations.go

@@ -3,6 +3,10 @@ package goautomation
 import (
 	"context"
 	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
 
 	appsv1 "k8s.io/api/apps/v1"
 	corev1 "k8s.io/api/core/v1"
@@ -142,3 +146,55 @@ func CreateResources(clientset *kubernetes.Clientset, yamlPath string) (error) {
     }
     return nil
 }
+
+func getResourceKind(path string) string {
+    dir := filepath.Dir(path)
+
+    parts := strings.Split(dir, string(os.PathSeparator))
+    kind := parts[len(parts)-1]
+    return kind
+}
+
+func getOrderIndex(kind string) int {
+    deploymentOrder := map[string]int{
+        "configmap": 0,
+        "deployment": 1,
+        "service": 2,
+    }
+    return deploymentOrder[kind]
+}
+
+func DeployResourcesFromDirectory(clientset *kubernetes.Clientset, kubeDir string) error {
+    deploymentOrder := []string{"configmap", "deployment", "service"}
+    resourceFiles := make(map[string][]string)
+    err := filepath.Walk(kubeDir, func(path string, info os.FileInfo, err error) error {
+        if err != nil {
+            return err
+        }
+
+        if !info.IsDir() {
+            resourceKind := getResourceKind(path)
+            resourceFiles[resourceKind] = append(resourceFiles[resourceKind], path)
+        }
+        return nil
+    })
+    if err != nil {
+        return err
+    }
+
+    sort.SliceStable(deploymentOrder, func(i, j int) bool {
+        return getOrderIndex(deploymentOrder[i]) < getOrderIndex(deploymentOrder[j])
+    })
+
+    for _, kind := range deploymentOrder{
+        files := resourceFiles[kind]
+        for _, file := range files {
+            fmt.Printf("file : %s", file)
+            err = CreateResources(clientset, file)
+            if err != nil {
+                return err
+            }
+        }
+    }
+    return nil
+}

go-automation/tests.go

@@ -0,0 +1,40 @@
+package goautomation
+
+import (
+    "fmt"
+	"k8s.io/client-go/kubernetes"
+)
+
+func ListAllResources(clientset *kubernetes.Clientset) {
+    // testing list resource
+
+    // list the deployments in the default namespace
+    deployments, err := ListResources(clientset, "Deployment")
+    if err != nil {
+        panic(err.Error())
+    }
+    fmt.Println("Deployments :")
+    for _, deployment := range deployments{
+        fmt.Println(deployment)
+    }
+    
+    // list the services in the default namespace
+    services, err := ListResources(clientset, "Service")
+    if err != nil {
+        panic(err.Error())
+    }
+    fmt.Println("Services:")
+    for _, service:= range services{
+        fmt.Println(service)
+    }
+
+    // list the configmaps in the default namespace
+    configmaps, err := ListResources(clientset, "ConfigMap")
+    if err != nil {
+        panic(err.Error())
+    }
+    fmt.Println("Configmaps:")
+    for _, configmap:= range configmaps{
+        fmt.Println(configmap)
+    }
+}

kube/nginx/configmap/configmap.yaml

@@ -0,0 +1,14 @@
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: nginx-configmap
+data:
+  nginx.conf: |
+    server {
+      listen 80;
+      server_name localhost;
+      location / {
+        root /usr/share/nginx/html;
+        index index.html;
+      }
+    }

nginx-deployment.yaml kube/nginx/deployment/deployment.yaml

@@ -3,17 +3,25 @@ kind: Deployment
 metadata:
   name: nginx-deployment
 spec:
+  replicas: 1
   selector:
     matchLabels:
       app: nginx
-  replicas: 1 
   template:
     metadata:
       labels:
         app: nginx
     spec:
       containers:
       - name: nginx
-        image: nginx:latest
+        image: nginx
         ports:
         - containerPort: 80
+        volumeMounts:
+        - name: nginx-config
+          mountPath: /etc/nginx/nginx.conf
+          subPath: nginx.conf
+      volumes:
+      - name: nginx-config
+        configMap:
+          name: nginx-configmap

kube/nginx/service/service.yaml

@@ -0,0 +1,12 @@
+apiVersion: v1
+kind: Service
+metadata:
+  name: nginx-service
+spec:
+  selector:
+    app: nginx
+  ports:
+    - protocol: TCP
+      port: 80
+      targetPort: 80
+  type: LoadBalancer