Merge pull request #268 from covexo/devspace-cloud

Devspace cloud

Author: FabianKramm

cmd/init.go

@@ -9,15 +9,19 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/covexo/devspace/pkg/util/kubeconfig"
+
+	"k8s.io/client-go/tools/clientcmd"
+
 	"github.com/covexo/devspace/pkg/devspace/clients/kubectl"
+	"github.com/covexo/devspace/pkg/devspace/cloud"
 
 	"github.com/covexo/devspace/pkg/devspace/builder/docker"
 
 	"github.com/covexo/devspace/pkg/devspace/config/configutil"
 	"github.com/covexo/devspace/pkg/devspace/generator"
 	"github.com/covexo/devspace/pkg/util/log"
 	"github.com/covexo/devspace/pkg/util/randutil"
-	homedir "github.com/mitchellh/go-homedir"
 
 	"github.com/covexo/devspace/pkg/devspace/config/v1"
 	"github.com/covexo/devspace/pkg/util/stdinutil"
@@ -116,6 +120,7 @@ func (cmd *InitCmd) Run(cobraCmd *cobra.Command, args []string) {
 	} else {
 		cmd.config = configutil.GetConfigInstance()
 	}
+
 	configutil.Merge(cmd.config, &v1.Config{
 		Version: configutil.String("v1"),
 		DevSpace: &v1.DevSpaceConfig{
@@ -217,7 +222,6 @@ func (cmd *InitCmd) initChartGenerator() {
 
 func (cmd *InitCmd) configureDevSpace() {
 	_, chartDirNotFound := os.Stat(cmd.workdir + "/chart")
-
 	if chartDirNotFound == nil {
 		/*TODO
 		existingChartYaml := map[interface{}]interface{}{}
@@ -239,18 +243,13 @@ func (cmd *InitCmd) configureDevSpace() {
 			}
 		}*/
 	}
+
 	cmd.config.DevSpace.Release.Name = stdinutil.GetFromStdin(&stdinutil.GetFromStdinParams{
 		Question:               "What is the name of your application?",
 		DefaultValue:           *cmd.config.DevSpace.Release.Name,
 		ValidationRegexPattern: v1.Kubernetes.RegexPatterns.Name,
 	})
 
-	// cmd.appConfig.Container.Ports, _ = strconv.Atoi(stdinutil.GetFromStdin(&stdinutil.GetFromStdin_params{
-	// 	Question:               "Which port(s) does your application listen on? (separated by spaces)",
-	// 	DefaultValue:           strconv.Itoa(cmd.appConfig.Container.Port),
-	// 	ValidationRegexPattern: "^[1-9][0-9]{0,4}?(\\s[1-9][0-9]{0,4})?$",
-	// }))
-
 	ports := strings.Split(*stdinutil.GetFromStdin(&stdinutil.GetFromStdinParams{
 		Question:               "Which port(s) does your application listen on? (separated by spaces)",
 		DefaultValue:           "",
@@ -266,11 +265,13 @@ func (cmd *InitCmd) configureDevSpace() {
 	}
 	cmd.addDefaultSyncConfig()
 
-	cmd.config.DevSpace.Release.Namespace = stdinutil.GetFromStdin(&stdinutil.GetFromStdinParams{
-		Question:               "Which Kubernetes namespace should your application run in?",
-		DefaultValue:           *cmd.config.DevSpace.Release.Namespace,
-		ValidationRegexPattern: v1.Kubernetes.RegexPatterns.Name,
-	})
+	if cmd.config.DevSpace.Release.Namespace == nil || len(*cmd.config.DevSpace.Release.Namespace) == 0 {
+		cmd.config.DevSpace.Release.Namespace = stdinutil.GetFromStdin(&stdinutil.GetFromStdinParams{
+			Question:               "Which Kubernetes namespace should your application run in?",
+			DefaultValue:           *cmd.config.DevSpace.Release.Namespace,
+			ValidationRegexPattern: v1.Kubernetes.RegexPatterns.Name,
+		})
+	}
 
 	/* TODO
 	cmd.appConfig.External.Domain = stdinutil.GetFromStdin(&stdinutil.GetFromStdinParams{
@@ -340,38 +341,111 @@ func (cmd *InitCmd) configureTiller() {
 	tillerConfig := cmd.config.Services.Tiller
 	tillerRelease := tillerConfig.Release
 
-	if tillerRelease.Namespace == nil {
+	if tillerRelease.Namespace == nil || len(*tillerRelease.Namespace) == 0 {
 		tillerRelease.Namespace = cmd.config.DevSpace.Release.Namespace
+
+		tillerRelease.Namespace = stdinutil.GetFromStdin(&stdinutil.GetFromStdinParams{
+			Question:               "Which Kubernetes namespace should your tiller server run in?",
+			DefaultValue:           *tillerRelease.Namespace,
+			ValidationRegexPattern: v1.Kubernetes.RegexPatterns.Name,
+		})
 	}
-	tillerRelease.Namespace = stdinutil.GetFromStdin(&stdinutil.GetFromStdinParams{
-		Question:               "Which Kubernetes namespace should your tiller server run in?",
-		DefaultValue:           *tillerRelease.Namespace,
-		ValidationRegexPattern: v1.Kubernetes.RegexPatterns.Name,
-	})
+}
+
+func (cmd *InitCmd) useCloudProvider() bool {
+	providerConfig, err := cloud.ParseCloudConfig()
+	if err != nil {
+		log.Fatalf("Error loading cloud config: %v", err)
+	}
+
+	if len(providerConfig) > 1 {
+		cloudProvider := "("
+
+		for name := range providerConfig {
+			if len(cloudProvider) > 1 {
+				cloudProvider += ", "
+			}
+
+			cloudProvider += name
+		}
+
+		cloudProvider += ")"
+		cloudProviderSelected := ""
+
+		for _, ok := providerConfig[cloudProviderSelected]; ok == false && cloudProviderSelected != "no"; {
+			cloudProviderSelected = *stdinutil.GetFromStdin(&stdinutil.GetFromStdinParams{
+				Question:     "Do you want to use a cloud provider? (no to skip) " + cloudProvider,
+				DefaultValue: cloud.DevSpaceCloudProviderName,
+			})
+		}
+
+		if cloudProviderSelected != "no" {
+			addToContext := *stdinutil.GetFromStdin(&stdinutil.GetFromStdinParams{
+				Question:               "Do you want to add the cloud provider to the $HOME/.kube/config file? (yes | no)",
+				DefaultValue:           "yes",
+				ValidationRegexPattern: "^(yes)|(no)$",
+			}) == "yes"
+
+			cmd.config.Cluster.CloudProvider = &cloudProviderSelected
+			cmd.config.Cluster.UseKubeConfig = &addToContext
+
+			err := cloud.Update(providerConfig, cmd.config, true)
+			if err != nil {
+				log.Fatalf("Couldn't authenticate to devspace cloud: %v", err)
+			}
+
+			return true
+		}
+	} else {
+		useDevSpaceCloud := *stdinutil.GetFromStdin(&stdinutil.GetFromStdinParams{
+			Question:               "Do you want to use the devspace cloud? (free ready-to-use kubernetes) (yes | no)",
+			DefaultValue:           "yes",
+			ValidationRegexPattern: "^(yes)|(no)$",
+		}) == "yes"
+
+		if useDevSpaceCloud {
+			addToContext := *stdinutil.GetFromStdin(&stdinutil.GetFromStdinParams{
+				Question:               "Do you want to add the devspace-cloud to the $HOME/.kube/config file? (yes | no)",
+				DefaultValue:           "yes",
+				ValidationRegexPattern: "^(yes)|(no)$",
+			}) == "yes"
+
+			cmd.config.Cluster.CloudProvider = configutil.String(cloud.DevSpaceCloudProviderName)
+			cmd.config.Cluster.UseKubeConfig = &addToContext
+
+			err := cloud.Update(providerConfig, cmd.config, true)
+			if err != nil {
+				log.Fatalf("Couldn't authenticate to devspace cloud: %v", err)
+			}
+
+			return true
+		}
+	}
+
+	return false
 }
 
 func (cmd *InitCmd) configureKubernetes() {
 	clusterConfig := cmd.config.Cluster
 	useKubeConfig := false
-	homeDir, homeErr := homedir.Dir()
 
-	if homeErr != nil {
-		log.With(homeErr).Fatalf("Unable to determine home dir")
+	// Check if devspace cloud should be used
+	if cmd.useCloudProvider() {
+		return
 	}
-	kubeConfigPath := homeDir + "/.kube/config"
 
-	_, kubeConfigNotFound := os.Stat(kubeConfigPath)
-
-	if kubeConfigNotFound == nil {
+	_, err := os.Stat(clientcmd.RecommendedHomeFile)
+	if err == nil {
 		skipAnswer := stdinutil.GetFromStdin(&stdinutil.GetFromStdinParams{
 			Question:               "Do you want to use your existing $HOME/.kube/config for Kubernetes access? (yes | no)",
 			DefaultValue:           "yes",
 			ValidationRegexPattern: "^(yes)|(no)$",
 		})
+
 		useKubeConfig = (*skipAnswer == "yes")
 	}
-	clusterConfig.UseKubeConfig = configutil.Bool(useKubeConfig)
 
+	clusterConfig.UseKubeConfig = configutil.Bool(useKubeConfig)
 	if !useKubeConfig {
 		if clusterConfig.APIServer == nil {
 			clusterConfig.APIServer = configutil.String("https://192.168.99.100:8443")
@@ -393,15 +467,10 @@ func (cmd *InitCmd) configureKubernetes() {
 
 		if clusterConfig.User == nil {
 			clusterConfig.User = &v1.ClusterUser{
-				Username:   configutil.String(""),
 				ClientCert: configutil.String(""),
 				ClientKey:  configutil.String(""),
 			}
 		} else {
-			if clusterConfig.User.Username == nil {
-				clusterConfig.User.Username = configutil.String("")
-			}
-
 			if clusterConfig.User.ClientCert == nil {
 				clusterConfig.User.ClientCert = configutil.String("")
 			}
@@ -410,11 +479,6 @@ func (cmd *InitCmd) configureKubernetes() {
 				clusterConfig.User.ClientKey = configutil.String("")
 			}
 		}
-		clusterConfig.User.Username = stdinutil.GetFromStdin(&stdinutil.GetFromStdinParams{
-			Question:               "What is your Kubernetes username?",
-			DefaultValue:           *clusterConfig.User.Username,
-			ValidationRegexPattern: v1.Kubernetes.RegexPatterns.Name,
-		})
 		clusterConfig.User.ClientCert = stdinutil.AskChangeQuestion(&stdinutil.GetFromStdinParams{
 			Question:               "What is your Kubernetes client certificate? (PEM)",
 			DefaultValue:           *clusterConfig.User.ClientCert,
@@ -425,6 +489,13 @@ func (cmd *InitCmd) configureKubernetes() {
 			DefaultValue:           *clusterConfig.User.ClientKey,
 			InputTerminationString: "-----END RSA PRIVATE KEY-----",
 		})
+	} else {
+		currentContext, err := kubeconfig.GetCurrentContext()
+		if err != nil {
+			log.Fatalf("Couldn't determine current kubernetes context: %v", err)
+		}
+
+		clusterConfig.KubeContext = &currentContext
 	}
 }
 

cmd/up.go

@@ -160,12 +160,14 @@ func (cmd *UpCmd) Run(cobraCmd *cobra.Command, args []string) {
 	mustRedeploy := cmd.buildImages()
 
 	// Check if we find a running release pod
-	config := configutil.GetConfig(false)
 	hash, err := hash.Directory("chart")
 	if err != nil {
 		log.Fatalf("Error hashing chart directory: %v", err)
 	}
 
+	// Load config
+	config := configutil.GetConfig(false)
+
 	pod, err := getRunningDevSpacePod(cmd.helm, cmd.kubectl)
 	if err != nil || mustRedeploy || cmd.flags.deploy || config.DevSpace.ChartHash == nil || *config.DevSpace.ChartHash != hash {
 		cmd.deployChart()

docs/docs/configuration/config.yaml.md

@@ -235,6 +235,7 @@ The `tiller` service is defined by:
 ## cluster
 The `cluster` field specifies:
 - `useKubeConfig` *bool* if true use the credentials defined in $HOME/.kube/config
+- `kubeContext` *string* the context to use from $HOME/.kube/config
 
 If `useKubeConfig` is `false`, the following fields need to be specified:
 - `apiServer` *string* (Kubernetes API-Server URL)
@@ -243,7 +244,6 @@ If `useKubeConfig` is `false`, the following fields need to be specified:
 
 ### cluster.user
 ClusterUser:
-- `username` *string*
 - `clientCert` *string* (PEM format)
 - `clientKey` *string* (PEM format)  
 

pkg/devspace/clients/kubectl/client.go

@@ -7,11 +7,12 @@ import (
 	"io"
 	"net/http"
 	"os"
-	"path/filepath"
 	"sync"
 
+	"github.com/covexo/devspace/pkg/util/kubeconfig"
+
+	"github.com/covexo/devspace/pkg/devspace/cloud"
 	"github.com/covexo/devspace/pkg/devspace/config/configutil"
-	"github.com/covexo/devspace/pkg/util/fsutil"
 	"github.com/covexo/devspace/pkg/util/log"
 	dockerterm "github.com/docker/docker/pkg/term"
 	k8sv1 "k8s.io/api/core/v1"
@@ -36,14 +37,57 @@ var isMinikubeVar *bool
 //NewClient creates a new kubernetes client
 func NewClient() (*kubernetes.Clientset, error) {
 	config, err := GetClientConfig()
-
 	if err != nil {
 		return nil, err
 	}
 
 	return kubernetes.NewForConfig(config)
 }
 
+//GetClientConfig loads the configuration for kubernetes clients and parses it to *rest.Config
+func GetClientConfig() (*rest.Config, error) {
+	config := configutil.GetConfig(false)
+	if config.Cluster == nil {
+		return nil, errors.New("Couldn't load cluster config, did you run devspace init")
+	}
+
+	// Update devspace cloud cluster config
+	if config.Cluster.CloudProvider != nil && *config.Cluster.CloudProvider != "" {
+		providerConfig, err := cloud.ParseCloudConfig()
+		if err != nil {
+			return nil, fmt.Errorf("Couldn't load cloud provider config: %v", err)
+		}
+
+		err = cloud.Update(providerConfig, config, false)
+		if err != nil {
+			log.Warnf("Couldn't update cloud provider %s information: %v", *config.Cluster.CloudProvider, err)
+		}
+	}
+
+	if (config.Cluster.UseKubeConfig != nil && *config.Cluster.UseKubeConfig) || config.Cluster.APIServer == nil {
+		// If we should use a certain kube context use that
+		if config.Cluster.KubeContext != nil && len(*config.Cluster.KubeContext) > 0 {
+			kubeConfig, err := kubeconfig.ReadKubeConfig(clientcmd.RecommendedHomeFile)
+			if err != nil {
+				return nil, err
+			}
+
+			return clientcmd.NewNonInteractiveClientConfig(*kubeConfig, *config.Cluster.KubeContext, nil, clientcmd.NewDefaultClientConfigLoadingRules()).ClientConfig()
+		}
+
+		return clientcmd.BuildConfigFromFlags("", clientcmd.RecommendedHomeFile)
+	}
+
+	return &rest.Config{
+		Host: *config.Cluster.APIServer,
+		TLSClientConfig: rest.TLSClientConfig{
+			CAData:   []byte(*config.Cluster.CaCert),
+			CertData: []byte(*config.Cluster.User.ClientCert),
+			KeyData:  []byte(*config.Cluster.User.ClientKey),
+		},
+	}, nil
+}
+
 // IsMinikube returns true if the Kubernetes cluster is a minikube
 func IsMinikube() bool {
 	if isMinikubeVar == nil {
@@ -204,28 +248,6 @@ func GetPodsFromDeployment(kubectl *kubernetes.Clientset, deployment, namespace
 	})
 }
 
-//GetClientConfig loads the configuration for kubernetes clients and parses it to *rest.Config
-func GetClientConfig() (*rest.Config, error) {
-	config := configutil.GetConfig(false)
-
-	if config.Cluster == nil {
-		return nil, errors.New("Couldn't load cluster config, did you run devspace init")
-	}
-
-	if (config.Cluster.UseKubeConfig != nil && *config.Cluster.UseKubeConfig) || config.Cluster.APIServer == nil {
-		return clientcmd.BuildConfigFromFlags("", filepath.Join(fsutil.GetHomeDir(), ".kube", "config"))
-	}
-	return &rest.Config{
-		Host:     *config.Cluster.APIServer,
-		Username: *config.Cluster.User.Username,
-		TLSClientConfig: rest.TLSClientConfig{
-			CAData:   []byte(*config.Cluster.CaCert),
-			CertData: []byte(*config.Cluster.User.ClientCert),
-			KeyData:  []byte(*config.Cluster.User.ClientKey),
-		},
-	}, nil
-}
-
 // ForwardPorts forwards the specified ports from the cluster to the local machine
 func ForwardPorts(kubectlClient *kubernetes.Clientset, pod *k8sv1.Pod, ports []string, stopChan chan struct{}, readyChan chan struct{}) error {
 	config, err := GetClientConfig()