scaleway
diff --git a/‎internal/namespaces/inference/v1/custom.go‎
Lines changed: 14 additions & 1 deletion b/‎internal/namespaces/inference/v1/custom.go‎
Lines changed: 14 additions & 1 deletion
diff --git a/‎internal/namespaces/inference/v1/custom_deployment.go‎
Lines changed: 147 additions & 0 deletions b/‎internal/namespaces/inference/v1/custom_deployment.go‎
Lines changed: 147 additions & 0 deletions
diff --git a/‎internal/namespaces/inference/v1/custom_deployment_test.go‎
Lines changed: 72 additions & 0 deletions b/‎internal/namespaces/inference/v1/custom_deployment_test.go‎
Lines changed: 72 additions & 0 deletions
diff --git a/‎internal/namespaces/inference/v1/helper_test.go‎
Lines changed: 29 additions & 0 deletions b/‎internal/namespaces/inference/v1/helper_test.go‎
Lines changed: 29 additions & 0 deletions
@@ -1,11 +1,24 @@
 package inference
 
-import "github.com/scaleway/scaleway-cli/v2/core"
+import (
+	"github.com/scaleway/scaleway-cli/v2/core"
+	"github.com/scaleway/scaleway-cli/v2/core/human"
+	"github.com/scaleway/scaleway-sdk-go/api/inference/v1"
+)
 
 func GetCommands() *core.Commands {
 	cmds := GetGeneratedCommands()
 
 	cmds.MustFind("inference").Groups = []string{"ai"}
 
+	human.RegisterMarshalerFunc(
+		inference.DeploymentStatus(""),
+		human.EnumMarshalFunc(deployementStateMarshalSpecs),
+	)
+
+	human.RegisterMarshalerFunc(inference.Deployment{}, DeploymentMarshalerFunc)
+
+	cmds.MustFind("inference", "deployment", "create").Override(deploymentCreateBuilder)
+
 	return cmds
 }
@@ -0,0 +1,147 @@
+package inference
+
+import (
+	"context"
+	"reflect"
+	"strings"
+	"time"
+
+	"github.com/fatih/color"
+	"github.com/scaleway/scaleway-cli/v2/core"
+	"github.com/scaleway/scaleway-cli/v2/core/human"
+	"github.com/scaleway/scaleway-sdk-go/api/inference/v1"
+	"github.com/scaleway/scaleway-sdk-go/scw"
+)
+
+const (
+	deploymentActionTimeout = 60 * time.Minute
+)
+
+var deployementStateMarshalSpecs = human.EnumMarshalSpecs{
+	inference.DeploymentStatusCreating:  &human.EnumMarshalSpec{Attribute: color.FgBlue},
+	inference.DeploymentStatusDeploying: &human.EnumMarshalSpec{Attribute: color.FgBlue},
+	inference.DeploymentStatusDeleting:  &human.EnumMarshalSpec{Attribute: color.FgBlue},
+	inference.DeploymentStatusError:     &human.EnumMarshalSpec{Attribute: color.FgRed},
+	inference.DeploymentStatusReady:     &human.EnumMarshalSpec{Attribute: color.FgGreen},
+	inference.DeploymentStatusLocked:    &human.EnumMarshalSpec{Attribute: color.FgRed},
+}
+
+func DeploymentMarshalerFunc(i any, opt *human.MarshalOpt) (string, error) {
+	type tmp inference.Deployment
+	deployment := tmp(i.(inference.Deployment))
+	opt.Sections = []*human.MarshalSection{
+		{
+			FieldName: "Endpoints",
+			Title:     "Endpoints",
+		},
+	}
+	str, err := human.Marshal(deployment, opt)
+	if err != nil {
+		return "", err
+	}
+
+	return str, nil
+}
+
+var completeListNodeTypesCache *inference.ListNodeTypesResponse
+
+func autocompleteDeploymentNodeType(
+	ctx context.Context,
+	prefix string,
+	request any,
+) core.AutocompleteSuggestions {
+	req := request.(*inference.CreateDeploymentRequest)
+	suggestions := core.AutocompleteSuggestions(nil)
+
+	client := core.ExtractClient(ctx)
+	api := inference.NewAPI(client)
+
+	if completeListNodeTypesCache == nil {
+		res, err := api.ListNodeTypes(&inference.ListNodeTypesRequest{
+			Region: req.Region,
+		})
+		if err != nil {
+			return nil
+		}
+		completeListNodeTypesCache = res
+	}
+
+	for _, nodeType := range completeListNodeTypesCache.NodeTypes {
+		if strings.HasPrefix(nodeType.Name, prefix) {
+			suggestions = append(suggestions, nodeType.Name)
+		}
+	}
+
+	return suggestions
+}
+
+func deploymentCreateBuilder(c *core.Command) *core.Command {
+	c.ArgSpecs.GetByName("node-type-name").AutoCompleteFunc = autocompleteDeploymentNodeType
+	type llmInferenceEndpointSpecCustom struct {
+		*inference.EndpointSpec
+		IsPublic bool `json:"is-public"`
+	}
+
+	type llmInferenceCreateDeploymentRequestCustom struct {
+		*inference.CreateDeploymentRequest
+		Endpoints []*llmInferenceEndpointSpecCustom `json:"endpoints"`
+	}
+
+	c.ArgSpecs.AddBefore("endpoints.{index}.private-network.private-network-id", &core.ArgSpec{
+		Name:     "endpoints.{index}.is-public",
+		Short:    "Will configure your public endpoint if true",
+		Required: false,
+		Default:  core.DefaultValueSetter("false"),
+	})
+
+	c.ArgsType = reflect.TypeOf(llmInferenceCreateDeploymentRequestCustom{})
+
+	c.WaitFunc = func(ctx context.Context, _, respI any) (any, error) {
+		api := inference.NewAPI(core.ExtractClient(ctx))
+
+		return api.WaitForDeployment(&inference.WaitForDeploymentRequest{
+			DeploymentID:  respI.(*inference.Deployment).ID,
+			Region:        respI.(*inference.Deployment).Region,
+			Status:        respI.(*inference.Deployment).Status,
+			Timeout:       scw.TimeDurationPtr(deploymentActionTimeout),
+			RetryInterval: core.DefaultRetryInterval,
+		})
+	}
+	c.Interceptor = func(ctx context.Context, argsI any, runner core.CommandRunner) (any, error) {
+		deploymentCreateCustomRequest := argsI.(*llmInferenceCreateDeploymentRequestCustom)
+		deploymentRequest := deploymentCreateCustomRequest.CreateDeploymentRequest
+		if deploymentCreateCustomRequest.Endpoints == nil {
+			publicEndpoint := &inference.EndpointPublicNetworkDetails{}
+			endpoint := inference.EndpointSpec{
+				PublicNetwork:  publicEndpoint,
+				PrivateNetwork: nil,
+				DisableAuth:    false,
+			}
+			deploymentRequest.Endpoints = append(deploymentRequest.Endpoints, &endpoint)
+
+			return runner(ctx, deploymentRequest)
+		}
+		for _, endpoint := range deploymentCreateCustomRequest.Endpoints {
+			publicEndpoint := &inference.EndpointPublicNetworkDetails{}
+			if !endpoint.IsPublic {
+				publicEndpoint = nil
+			}
+			privateNetwork := &inference.EndpointPrivateNetworkDetails{}
+			if endpoint.PrivateNetwork == nil {
+				privateNetwork = nil
+			} else {
+				privateNetwork.PrivateNetworkID = endpoint.PrivateNetwork.PrivateNetworkID
+			}
+			endpoint := inference.EndpointSpec{
+				PublicNetwork:  publicEndpoint,
+				PrivateNetwork: privateNetwork,
+				DisableAuth:    endpoint.DisableAuth,
+			}
+			deploymentRequest.Endpoints = append(deploymentRequest.Endpoints, &endpoint)
+		}
+
+		return runner(ctx, deploymentRequest)
+	}
+
+	return c
+}
@@ -0,0 +1,72 @@
+package inference_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/scaleway/scaleway-cli/v2/core"
+	inference "github.com/scaleway/scaleway-cli/v2/internal/namespaces/inference/v1"
+	"github.com/scaleway/scaleway-cli/v2/internal/namespaces/vpc/v2"
+)
+
+const (
+	ModelID      = "739d51ae-4f1e-4193-a4bf-f7380c090d46"
+	NodeTypeName = "H100-2"
+)
+
+func Test_DeploymentCreate(t *testing.T) {
+	cmds := inference.GetCommands()
+
+	t.Run("Simple deployment", core.Test(&core.TestConfig{
+		Commands: cmds,
+		Cmd:      fmt.Sprintf("scw inference deployment create node-type-name=%s model-id=%s", NodeTypeName, ModelID),
+		Check:    core.TestCheckGolden(),
+		AfterFunc: core.ExecAfterCmd(
+			"scw inference deployment delete {{ .CmdResult.ID }}",
+		),
+	}))
+
+	t.Run("Deployment with wait flag", core.Test(&core.TestConfig{
+		Commands: cmds,
+		Cmd: fmt.Sprintf(
+			"scw inference deployment create node-type-name=%s model-id=%s accept-eula=true --wait",
+			NodeTypeName, ModelID,
+		),
+		Check: core.TestCheckGolden(),
+		AfterFunc: core.ExecAfterCmd(
+			"scw inference deployment delete {{ .CmdResult.ID }}",
+		),
+	}))
+}
+
+func Test_CreateDeploymentPrivateEndpoint(t *testing.T) {
+	cmds := inference.GetCommands()
+	cmds.Merge(vpc.GetCommands())
+
+	t.Run("Create Deployment Private Endpoint", core.Test(&core.TestConfig{
+		Commands:   cmds,
+		BeforeFunc: CreatePN(),
+		Cmd: fmt.Sprintf(
+			"scw inference deployment create model-id=%s node-type-name=%s accept-eula=true endpoints.0.private-network.private-network-id={{ .PN.ID }}",
+			ModelID, NodeTypeName,
+		),
+		Check: core.TestCheckCombine(
+			core.TestCheckGolden(),
+		),
+		AfterFunc: core.AfterFuncCombine(
+			DeletePrivateNetwork(),
+			DeleteDeployment(),
+		),
+	}))
+}
+
+func Test_DeploymentDelete(t *testing.T) {
+	cmds := inference.GetCommands()
+
+	t.Run("Delete deployment with wait flag", core.Test(&core.TestConfig{
+		Commands:   cmds,
+		BeforeFunc: CreateDeploymentPublicEndpoint(),
+		Cmd:        "scw inference deployment delete {{ .DEPLOYMENT.ID }} -w",
+		Check:      core.TestCheckGolden(),
+	}))
+}
@@ -0,0 +1,29 @@
+package inference_test
+
+import (
+	"fmt"
+
+	"github.com/scaleway/scaleway-cli/v2/core"
+)
+
+func CreateDeploymentPublicEndpoint() core.BeforeFunc {
+	return core.ExecStoreBeforeCmd(
+		"DEPLOYMENT",
+		fmt.Sprintf("scw inference deployment create node-type-name=%s model-id=%s -w", NodeTypeName, ModelID),
+	)
+}
+
+func CreatePN() core.BeforeFunc {
+	return core.ExecStoreBeforeCmd(
+		"PN",
+		"scw vpc private-network create",
+	)
+}
+
+func DeletePrivateNetwork() core.AfterFunc {
+	return core.ExecAfterCmd("scw vpc private-network delete {{ .PN.ID }}")
+}
+
+func DeleteDeployment() core.AfterFunc {
+	return core.ExecAfterCmd("scw inference deployment delete {{ .DEPLOYMENT.ID }}")
+}