deployment command: Remove flag based create (#460)

Removes the flags to change the deployment create request properties
and instead adds the ability to use the deployment template defaults and
document a workflow that can be used to easily tweak those settings and
create a deployment with the file declaration instead.

Signed-off-by: Marc Lopez <marc5.12@outlook.com>

Author: marclop

cmd/deployment/create.go

@@ -18,14 +18,12 @@
 package cmddeployment
 
 import (
-	"encoding/json"
 	"errors"
 	"fmt"
 	"strings"
 
 	"github.com/elastic/cloud-sdk-go/pkg/api/deploymentapi"
-	"github.com/elastic/cloud-sdk-go/pkg/api/deploymentapi/deploymentsize"
-	"github.com/elastic/cloud-sdk-go/pkg/api/deploymentapi/depresourceapi"
+	"github.com/elastic/cloud-sdk-go/pkg/api/deploymentapi/deptemplateapi"
 	"github.com/elastic/cloud-sdk-go/pkg/models"
 	"github.com/elastic/cloud-sdk-go/pkg/multierror"
 	sdkcmdutil "github.com/elastic/cloud-sdk-go/pkg/util/cmdutil"
@@ -42,141 +40,37 @@ var createCmd = &cobra.Command{
 	Long:    createLong,
 	Example: createExample,
 	RunE: func(cmd *cobra.Command, args []string) error {
-		var file, _ = cmd.Flags().GetString("file")
-		var track, _ = cmd.Flags().GetBool("track")
-		var generatePayload, _ = cmd.Flags().GetBool("generate-payload")
-		var name, _ = cmd.Flags().GetString("name")
-		var version, _ = cmd.Flags().GetString("version")
-		var dt, _ = cmd.Flags().GetString("deployment-template")
-		var region = ecctl.Get().Config.Region
+		track, _ := cmd.Flags().GetBool("track")
+		generatePayload, _ := cmd.Flags().GetBool("generate-payload")
+		name, _ := cmd.Flags().GetString("name")
+		version, _ := cmd.Flags().GetString("version")
+		region := ecctl.Get().Config.Region
 
-		var esZoneCount, _ = cmd.Flags().GetInt32("es-zones")
-		var esSize, _ = cmd.Flags().GetString("es-size")
-		var esRefID, _ = cmd.Flags().GetString("es-ref-id")
-		var topologyElements, _ = cmd.Flags().GetStringArray("es-node-topology")
-		var plugin, _ = cmd.Flags().GetStringSlice("plugin")
-
-		var kibanaZoneCount, _ = cmd.Flags().GetInt32("kibana-zones")
-		var kibanaSize, _ = cmd.Flags().GetString("kibana-size")
-		var kibanaRefID, _ = cmd.Flags().GetString("kibana-ref-id")
-
-		var apmEnable, _ = cmd.Flags().GetBool("apm")
-		var apmZoneCount, _ = cmd.Flags().GetInt32("apm-zones")
-		var apmSize, _ = cmd.Flags().GetString("apm-size")
-		var apmRefID, _ = cmd.Flags().GetString("apm-ref-id")
-
-		var appsearchEnable, _ = cmd.Flags().GetBool("appsearch")
-		var appsearchZoneCount, _ = cmd.Flags().GetInt32("appsearch-zones")
-		var appsearchSize, _ = cmd.Flags().GetString("appsearch-size")
-		var appsearchRefID, _ = cmd.Flags().GetString("appsearch-ref-id")
-
-		var enterpriseSearchEnable, _ = cmd.Flags().GetBool("enterprise_search")
-		var enterpriseSearchZoneCount, _ = cmd.Flags().GetInt32("enterprise_search-zones")
-		var enterpriseSearchSize, _ = cmd.Flags().GetString("enterprise_search-size")
-		var enterpriseSearchRefID, _ = cmd.Flags().GetString("enterprise_search-ref-id")
-
-		var payload *models.DeploymentCreateRequest
-
-		if file != "" {
-			err := sdkcmdutil.DecodeDefinition(cmd, "file", &payload)
-			if err != nil {
-				merr := multierror.NewPrefixed("failed reading the file definition")
-				return merr.Append(err,
-					errors.New("could not read the specified file, please make sure it exists"),
-				)
-			}
-		}
-
-		if dt == "" {
-			dt = setDefaultTemplate(region)
-		}
-
-		apmSizeMB, err := deploymentsize.ParseGb(apmSize)
-		if err != nil {
-			return err
-		}
-
-		appsearchSizeMB, err := deploymentsize.ParseGb(appsearchSize)
-		if err != nil {
-			return err
-		}
-
-		esSizeMB, err := deploymentsize.ParseGb(esSize)
+		payload, err := newCreatePayload(cmd, version, region)
 		if err != nil {
 			return err
 		}
 
-		enterpriseSearchSizeMB, err := deploymentsize.ParseGb(enterpriseSearchSize)
-		if err != nil {
-			return err
-		}
-
-		kibanaSizeMB, err := deploymentsize.ParseGb(kibanaSize)
-		if err != nil {
+		if err := deploymentapi.OverrideCreateOrUpdateRequest(payload,
+			&deploymentapi.PayloadOverrides{
+				Name:               name,
+				Version:            version,
+				Region:             region,
+				ElasticsearchRefID: "main-elasticsearch",
+				OverrideRefIDs:     true,
+			},
+		); err != nil {
 			return err
 		}
 
-		if topologyElements != nil {
-			topologyElements, err = esTopologyParseGB(topologyElements)
-			if err != nil {
-				return err
-			}
-		}
-
-		if payload == nil {
-			var err error
-			payload, err = depresourceapi.NewPayload(depresourceapi.NewPayloadParams{
-				API:                    ecctl.Get().API,
-				Name:                   name,
-				DeploymentTemplateID:   dt,
-				Version:                version,
-				Region:                 region,
-				Writer:                 ecctl.Get().Config.ErrorDevice,
-				Plugins:                plugin,
-				TopologyElements:       topologyElements,
-				ApmEnable:              apmEnable,
-				AppsearchEnable:        appsearchEnable,
-				EnterpriseSearchEnable: enterpriseSearchEnable,
-				ElasticsearchInstance: depresourceapi.InstanceParams{
-					RefID:     esRefID,
-					Size:      esSizeMB,
-					ZoneCount: esZoneCount,
-				},
-				KibanaInstance: depresourceapi.InstanceParams{
-					RefID:     kibanaRefID,
-					Size:      kibanaSizeMB,
-					ZoneCount: kibanaZoneCount,
-				},
-				ApmInstance: depresourceapi.InstanceParams{
-					RefID:     apmRefID,
-					Size:      apmSizeMB,
-					ZoneCount: apmZoneCount,
-				},
-				AppsearchInstance: depresourceapi.InstanceParams{
-					RefID:     appsearchRefID,
-					Size:      appsearchSizeMB,
-					ZoneCount: appsearchZoneCount,
-				},
-				EnterpriseSearchInstance: depresourceapi.InstanceParams{
-					RefID:     enterpriseSearchRefID,
-					Size:      enterpriseSearchSizeMB,
-					ZoneCount: enterpriseSearchZoneCount,
-				},
-			})
-			if err != nil {
-				return err
-			}
-		}
-
 		// Returns the DeploymentCreateRequest skipping the creation of the resources.
 		if generatePayload {
 			return ecctl.Get().Formatter.Format("", payload)
 		}
 
 		reqID, _ := cmd.Flags().GetString("request-id")
 		reqID = deploymentapi.RequestID(reqID)
-
-		var createParams = deploymentapi.CreateParams{
+		createParams := deploymentapi.CreateParams{
 			API:       ecctl.Get().API,
 			RequestID: reqID,
 			Request:   payload,
@@ -213,31 +107,6 @@ func initFlags() {
 	createCmd.Flags().BoolP("track", "t", false, cmdutil.TrackFlagMessage)
 	createCmd.Flags().Bool("generate-payload", false, "Returns the deployment payload without actually creating the deployment resources")
 	createCmd.Flags().String("request-id", "", "Optional request ID - Can be found in the Stderr device when a previous deployment creation failed. For more information see the examples in the help command page")
-
-	createCmd.Flags().String("es-ref-id", "main-elasticsearch", "Optional RefId for the Elasticsearch deployment")
-	createCmd.Flags().Int32("es-zones", 1, "Number of zones the Elasticsearch instances will span")
-	createCmd.Flags().String("es-size", "4g", "Memory (RAM) in GB that each of the Elasticsearch instances will have")
-	createCmd.Flags().StringArrayP("es-node-topology", "e", nil, "Optional Elasticsearch node topology element definition. See help for more information")
-	createCmd.Flags().StringSlice("plugin", nil, "Additional plugins to add to the Elasticsearch deployment")
-
-	createCmd.Flags().String("kibana-ref-id", "main-kibana", "Optional RefId for the Kibana deployment")
-	createCmd.Flags().Int32("kibana-zones", 1, "Number of zones the Kibana instances will span")
-	createCmd.Flags().String("kibana-size", "1g", "Memory (RAM) in GB that each of the Kibana instances will have")
-
-	createCmd.Flags().Bool("apm", false, "Enables APM for the deployment")
-	createCmd.Flags().String("apm-ref-id", "main-apm", "Optional RefId for the APM deployment")
-	createCmd.Flags().Int32("apm-zones", 1, "Number of zones the APM instances will span")
-	createCmd.Flags().String("apm-size", "0.5g", "Memory (RAM) in GB that each of the APM instances will have")
-
-	createCmd.Flags().Bool("appsearch", false, "Enables App Search for the deployment")
-	createCmd.Flags().String("appsearch-ref-id", "main-appsearch", "Optional RefId for the App Search deployment")
-	createCmd.Flags().Int32("appsearch-zones", 1, "Number of zones the App Search instances will span")
-	createCmd.Flags().String("appsearch-size", "2g", "Memory (RAM) in GB that each of the App Search instances will have")
-
-	createCmd.Flags().Bool("enterprise_search", false, "Enables Enterprise Search for the deployment")
-	createCmd.Flags().String("enterprise_search-ref-id", "main-enterprise_search", "Optional RefId for the Enterprise Search deployment")
-	createCmd.Flags().Int32("enterprise_search-zones", 1, "Number of zones the Enterprise Search instances will span")
-	createCmd.Flags().String("enterprise_search-size", "4g", "Memory (RAM) in GB that each of the Enterprise Search instances will have")
 }
 
 func setDefaultTemplate(region string) string {
@@ -261,43 +130,33 @@ func setDefaultTemplate(region string) string {
 	}
 }
 
-type elasticsearchTopologyElement struct {
-	NodeType  string `json:"node_type"`
-	Size      string `json:"size"`
-	ZoneCount int32  `json:"zone_count,omitempty"`
-}
-
-func esTopologyParseGB(topology []string) ([]string, error) {
-	var t = make([]string, 0, len(topology))
-	for _, rawElement := range topology {
-		var element elasticsearchTopologyElement
-		if err := json.Unmarshal([]byte(rawElement), &element); err != nil {
-			return nil, fmt.Errorf("failed unpacking raw elasticsearch node topology: %s", err)
-		}
-
-		if element.Size == "" {
-			return nil, errors.New("elasticsearch node topology: memory size cannot be empty")
-		}
-
-		elementSizeMB, err := deploymentsize.ParseGb(element.Size)
-		if err != nil {
-			return nil, err
-		}
-
-		esTopologyElement := depresourceapi.ElasticsearchTopologyElement{
-			NodeType:  element.NodeType,
-			ZoneCount: element.ZoneCount,
-			Size:      elementSizeMB,
-		}
-
-		b, err := json.Marshal(esTopologyElement)
-		if err != nil {
-			return nil, fmt.Errorf("failed unpacking elasticsearch node topology: %s", err)
+func newCreatePayload(cmd *cobra.Command, version, region string) (*models.DeploymentCreateRequest, error) {
+	file, _ := cmd.Flags().GetString("file")
+	dt, _ := cmd.Flags().GetString("deployment-template")
+	var payload models.DeploymentCreateRequest
+	if file != "" {
+		if err := sdkcmdutil.DecodeDefinition(cmd, "file", &payload); err != nil {
+			merr := multierror.NewPrefixed("failed reading the file definition")
+			return nil, merr.Append(err,
+				errors.New("could not read the specified file, please make sure it exists"),
+			)
 		}
-		parsedElement := string(b)
+		return &payload, nil
+	}
 
-		t = append(t, parsedElement)
+	if dt == "" {
+		dt = setDefaultTemplate(region)
+		fmt.Fprintf(cmd.ErrOrStderr(), "--deployment-template not set, using %s", dt)
+	}
+	tpl, err := deptemplateapi.Get(deptemplateapi.GetParams{
+		API:          ecctl.Get().API,
+		TemplateID:   dt,
+		Region:       region,
+		StackVersion: version,
+	})
+	if err != nil {
+		return nil, err
 	}
 
-	return t, nil
+	return tpl.DeploymentTemplate, nil
 }

cmd/deployment/create_help.go

@@ -19,51 +19,38 @@ package cmddeployment
 
 const (
 	// nolint
-	createLong = `Creates a deployment which can be defined through flags or from a file definition.
-Sane default values are provided, making the command work out of the box even when no parameters are set. 
-When version is not specified, the latest available stack version will automatically be used. 
+	createLong = `Creates a deployment from a file definition or using the defaults from the deployment template.
+Default values are provided by the deployment template, simplifying the getting started experience.
+When version is not specified, the latest available stack version will automatically be used.
 These are the available options:
 
-  * Simplified flags to set size and zone count for each instance type (Elasticsearch, Kibana, APM, Enterprise Search and App Search). 
-  * Advanced flag for different Elasticsearch node types: --es-node-topology <json obj> (shorthand: -e).
-    Note that the flag can be specified multiple times for complex topologies.
-    The JSON object has the following format:
-    {
-      "node_type": "["data", "master", "ml"]" # type string
-      "size": "1g" # type string
-      "zone_count": 1 # type int32
-    }
+  * Using the deployment template defaults with --deployment-template=<deployment template id>
+  * Using the deployment template defaults with --deployment-template=<deployment template id> and 
+    --generate-payload to use the deployment template, modify certain fields of the definition and
+    use the --file flag to create the deployment.
   * File definition: --file=<file path> (shorthand: -f). You can create a definition by using the sample JSON seen here:
     https://elastic.co/guide/en/cloud/current/ec-api-deployment-crud.html#ec_create_a_deployment
 
 As an option "--generate-payload" can be used in order to obtain the generated payload that would be sent as a request. 
 Save it, update or extend the topology and create a deployment using the saved payload with the "--file" flag.`
 
 	// nolint
-	createExample = `## Create a deployment with the default values for Elasticsearch, a Kibana instance with a modified size, 
-and a default APM instance. While Elasticsearch and Kibana come enabled by default, APM, Enterprise Search and App Search need to be 
-enabled by using the "--apm", "--enterprise_search" and "--appsearch" flags. The command will exit after the API response has been returned, without 
-waiting until the deployment resources have been created. 
-$ ecctl deployment create --name my-deployment --zones 2 --kibana-size 2g --apm --apm-size 0.5g
+	createExample = `## Create a deployment with the default values
+$ ecctl deployment create --name my-deployment --deployment-template=aws-io-optimized-v2 --region=us-east-1
 
 ## To make the command wait until the resources have been created use the "--track" flag, which will output 
 the current stage on which the deployment resources are in.
-$ deployment create --name my-deployment --track
+$ ecctl deployment create --name my-deployment --deployment-template=aws-io-optimized-v2 --region=us-east-1 --track
 [...]
 Deployment [b6ecbea3d5c84124b7dca457f2892086] - [Elasticsearch][b6ecbea3d5c84124b7dca457f2892086]: finished running all the plan steps (Total plan duration: 5m11.s)
 Deployment [91c4d60acb804ba0a27651fac02780ec] - [Kibana][8a9d9916cd6e46a7bb0912211d76e2af]: finished running all the plan steps (Total plan duration: 4m29.58s)
 
-## Additionally, a more advanced topology for Elasticsearch can be created through "--es-node-topology" or shorthand "-e".
-The following command will create a deployment with two 1GB Elasticsearch instances of the type "data" and 
-one 1GB Elasticsearch instance of the type "ml".
-$ ecctl deployment create --name my-deployment --es-node-topology '{"size": "1g", "zone_count": 2, "node_type": "data"}' --es-node-topology '{"size": "1g", "zone_count": 1, "node_type": "ml"}'
-
 ## In order to use the "--deployment-template" flag, you'll need to know which deployment templates ara available to you.
 You'll need to run the following command to view your deployment templates:
 $ ecctl platform deployment-template list
 
 ## Use the "--generate-payload" flag to save the definition to a file for later use.
-$ ecctl deployment create --name my-deployment --size 1g --track --generate-payload --zones 2 > create_example.json
+$ ecctl deployment create --name my-deployment --version=7.11.2 --generate-payload > create_example.json
 
 ## Create a deployment through the file definition.
 $ ecctl deployment create --file create_example.json --track