Add command to generate Kubernetes Secrets

cmd/internal/cmderr/checks.go

@@ -0,0 +1,26 @@
+package cmderr
+
+import (
+	"errors"
+	"github.com/akitasoftware/akita-cli/cfg"
+	"github.com/akitasoftware/akita-cli/env"
+	"github.com/akitasoftware/akita-cli/printer"
+)
+
+// Checks that a user has configured their API key and secret and returned them.
+// If the user has not configured their API key, a user-friendly error message is printed and an error is returned.
+func RequireAPICredentials(explanation string) (string, string, error) {
+	key, secret := cfg.GetAPIKeyAndSecret()
+	if key == "" || secret == "" {
+		printer.Errorf("No Akita API key configured. %s\n", explanation)
+		if env.InDocker() {
+			printer.Infof("Please set the AKITA_API_KEY_ID and AKITA_API_KEY_SECRET environment variables on the Docker command line.\n")
+		} else {
+			printer.Infof("Use the AKITA_API_KEY_ID and AKITA_API_KEY_SECRET environment variables, or run 'akita login'.\n")
+		}
+
+		return "", "", AkitaErr{Err: errors.New("could not find an Akita API key to use")}
+	}
+
+	return key, secret, nil
+}

cmd/internal/ecs/ecs.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/akitasoftware/akita-cli/cfg"
 	"github.com/akitasoftware/akita-cli/cmd/internal/cmderr"
 	"github.com/akitasoftware/akita-cli/env"
 	"github.com/akitasoftware/akita-cli/printer"
@@ -84,7 +83,10 @@ func init() {
 
 func addAgentToECS(cmd *cobra.Command, args []string) error {
 	// Check for API key
-	key, secret := cfg.GetAPIKeyAndSecret()
+	key, secret, err := cmderr.RequireAPICredentials("The Akita agent must have an API key in order to capture traces.")
+	if err != nil {
+		return err
+	}
 	if key == "" || secret == "" {
 		printer.Errorf("No Akita API key configured. The Akita agent must have an API key in order to capture traces.\n")
 		if env.InDocker() {
@@ -100,7 +102,7 @@ func addAgentToECS(cmd *cobra.Command, args []string) error {
 		return errors.New("Must specify the name of your Akita project with the --project flag.")
 	}
 	frontClient := rest.NewFrontClient(rest.Domain, telemetry.GetClientID())
-	_, err := util.GetServiceIDByName(frontClient, projectFlag)
+	_, err = util.GetServiceIDByName(frontClient, projectFlag)
 	if err != nil {
 		// TODO: we _could_ offer to create it, instead.
 		if strings.Contains(err.Error(), "cannot determine project ID") {

cmd/internal/kube/kube.go

@@ -0,0 +1,15 @@
+package kube
+
+import (
+	"github.com/akitasoftware/akita-cli/cmd/internal/cmderr"
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+)
+
+var Cmd = &cobra.Command{
+	Use:   "kube",
+	Short: "Gateway to Kubernetes related utilities",
+	RunE: func(_ *cobra.Command, _ []string) error {
+		return cmderr.AkitaErr{Err: errors.New("no subcommand specified")}
+	},
+}

cmd/internal/kube/secret.go

@@ -0,0 +1,127 @@
+package kube
+
+import (
+	"encoding/base64"
+	"log"
+	"os"
+	"path/filepath"
+	"text/template"
+
+	"github.com/akitasoftware/akita-cli/printer"
+
+	"github.com/akitasoftware/akita-cli/cmd/internal/cmderr"
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+)
+
+var (
+	output    string
+	namespace string
+	// Store a parsed representation of /template/akita-secret.tmpl
+	secretTemplate *template.Template
+)
+
+var secretCmd = &cobra.Command{
+	Use:   "secret",
+	Short: "Generate a Kubernetes secret config for Akita",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		key, secret, err := cmderr.RequireAPICredentials("Akita API key is required for Kubernetes Secret generation")
+		if err != nil {
+			return err
+		}
+
+		err = handleSecretGeneration(namespace, key, secret, output)
+		if err != nil {
+			return err
+		}
+
+		printer.Infoln("Generated Kubernetes secret config to ", output)
+		return nil
+	},
+}
+
+// Represents the input used by secretTemplate
+type secretTemplateInput struct {
+	Namespace string
+	APIKey    string
+	APISecret string
+}
+
+// Generates a Kubernetes secret config file for Akita
+func handleSecretGeneration(namespace, key, secret, output string) error {
+
+	input := secretTemplateInput{
+		Namespace: namespace,
+		APIKey:    base64.StdEncoding.EncodeToString([]byte(key)),
+		APISecret: base64.StdEncoding.EncodeToString([]byte(secret)),
+	}
+
+	secretFile, err := createSecretFile(output)
+	if err != nil {
+		return cmderr.AkitaErr{Err: errors.Wrap(err, "failed to create output file")}
+	}
+
+	defer secretFile.Close()
+
+	err = secretTemplate.Execute(secretFile, input)
+	if err != nil {
+		return cmderr.AkitaErr{Err: errors.Wrap(err, "failed to generate template")}
+	}
+
+	return nil
+}
+
+// Creates a file at the give path to be used for storing of the generated Secret config
+// If any child dicrectories do not exist, it will be created.
+func createSecretFile(path string) (*os.File, error) {
+	// Split the outut flag value into directory and filename
+	outputDir, outputName := filepath.Split(path)
+
+	// Get the absolute path of the output directory
+	absOutputDir, err := filepath.Abs(outputDir)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to resolve the absolute path of the output directory")
+	}
+
+	// Check if the output file already exists
+	outputFilePath := filepath.Join(absOutputDir, outputName)
+	if _, statErr := os.Stat(outputFilePath); statErr == nil {
+		return nil, errors.Errorf("output file %s already exists", outputFilePath)
+	}
+
+	// Create the output directory if it doesn't exist
+	err = os.MkdirAll(absOutputDir, 0755)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to create the output directory")
+	}
+
+	// Create the output file in the output directory
+	outputFile, err := os.Create(outputFilePath)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to create the output file")
+	}
+
+	return outputFile, nil
+}
+
+func init() {
+	var err error
+
+	secretTemplate, err = template.ParseFS(templateFS, "template/akita-secret.tmpl")
+	if err != nil {
+		log.Fatalf("unable to parse kube secret template: %v", err)
+	}
+
+	secretCmd.Flags().StringVarP(
+		&namespace,
+		"namespace",
+		"n",
+		"",
+		"The Kuberenetes namespace the secret should be applied to",
+	)
+	_ = secretCmd.MarkFlagRequired("namespace")
+
+	secretCmd.Flags().StringVarP(&output, "output", "o", "akita-secret.yml", "File to output the generated secret.")
+
+	Cmd.AddCommand(secretCmd)
+}

cmd/internal/kube/secret_test.go

@@ -0,0 +1,38 @@
+package kube
+
+import (
+	_ "embed"
+	"github.com/stretchr/testify/assert"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+//go:embed test_resource/akita-secret.yml
+var testAkitaSecretYAML []byte
+
+func Test_secretGeneration(t *testing.T) {
+	// GIVEN
+	const (
+		namespace = "default"
+		key       = "api-key"
+		secret    = "api-secret"
+	)
+
+	dir := t.TempDir()
+	actualOutput := filepath.Join(dir, "configurations", "akita-secret.yml")
+
+	// WHEN
+	err := handleSecretGeneration(namespace, key, secret, actualOutput)
+	if err != nil {
+		t.Errorf("Unexpected error: %s", err)
+	}
+
+	// THEN
+	actualFile, err := os.ReadFile(actualOutput)
+	if err != nil {
+		t.Errorf("Failed to read generated file: %v", err)
+	}
+
+	assert.Equal(t, string(testAkitaSecretYAML), string(actualFile))
+}

cmd/internal/kube/template.go

@@ -0,0 +1,6 @@
+package kube
+
+import "embed"
+
+//go:embed template
+var templateFS embed.FS

cmd/internal/kube/template/akita-secret.tmpl

@@ -0,0 +1,9 @@
+apiVersion: v1
+kind: Secret
+metadata:
+  name: akita-secrets
+  namespace: {{.Namespace}}
+type: Opaque
+data:
+  akita-api-key: {{.APIKey}}
+  akita-api-secret: {{.APISecret}}

cmd/internal/kube/test_resource/akita-secret.yml

@@ -0,0 +1,9 @@
+apiVersion: v1
+kind: Secret
+metadata:
+  name: akita-secrets
+  namespace: default
+type: Opaque
+data:
+  akita-api-key: YXBpLWtleQ==
+  akita-api-secret: YXBpLXNlY3JldA==

cmd/root.go

@@ -22,6 +22,7 @@ import (
 	"github.com/akitasoftware/akita-cli/cmd/internal/daemon"
 	"github.com/akitasoftware/akita-cli/cmd/internal/ecs"
 	"github.com/akitasoftware/akita-cli/cmd/internal/get"
+	"github.com/akitasoftware/akita-cli/cmd/internal/kube"
 	"github.com/akitasoftware/akita-cli/cmd/internal/learn"
 	"github.com/akitasoftware/akita-cli/cmd/internal/legacy"
 	"github.com/akitasoftware/akita-cli/cmd/internal/login"
@@ -279,6 +280,7 @@ func init() {
 	rootCmd.AddCommand(ci_guard.GuardCommand(get.Cmd))
 	rootCmd.AddCommand(ecs.Cmd)
 	rootCmd.AddCommand(nginx.Cmd)
+	rootCmd.AddCommand(kube.Cmd)
 
 	// Legacy commands, included for backward compatibility but are hidden.
 	legacy.SessionsCmd.Hidden = true