From 89f68dc086e9130d8f1a6e64b03da602a61284b4 Mon Sep 17 00:00:00 2001 From: Deatcu Andrei-Cristian Date: Mon, 22 Apr 2024 19:23:34 +0300 Subject: [PATCH] feat: Add 'lans' property for Dataplatform clusters (#541) * feat: Add 'lans' property for Dataplatform clusters * refactor: Add/move some error checks * doc: Add documentation for new 'lans' attribute --- CHANGELOG.md | 1 + docs/data-sources/dataplatform_cluster.md | 6 + docs/resources/dataplatform_cluster.md | 32 +- go.mod | 2 +- go.sum | 4 +- .../data_source_dataplatform_cluster.go | 53 ++- ionoscloud/resource_dataplatform_cluster.go | 44 ++- services/dataplatform/cluster.go | 87 ++++- services/dataplatform/nodepool.go | 12 +- services/dataplatform/versions.go | 8 +- .../sdk-go-dataplatform/.gitbook.yaml | 4 + .../ionos-cloud/sdk-go-dataplatform/README.md | 167 +++++---- .../api_data_platform_cluster.go | 343 +++++++++--------- .../api_data_platform_meta_data.go | 18 +- .../api_data_platform_node_pool.go | 268 +++++++------- .../ionos-cloud/sdk-go-dataplatform/client.go | 27 +- .../sdk-go-dataplatform/configuration.go | 8 +- .../ionos-cloud/sdk-go-dataplatform/logger.go | 4 +- .../model_availability_zone.go | 12 +- .../sdk-go-dataplatform/model_cluster.go | 54 ++- .../model_cluster_list_response_data.go | 6 +- .../model_cluster_response_data.go | 6 +- .../model_create_cluster_properties.go | 52 ++- .../model_create_cluster_request.go | 6 +- .../model_create_node_pool_properties.go | 22 +- .../model_create_node_pool_request.go | 6 +- .../model_error_message.go | 6 +- .../model_error_response.go | 6 +- .../sdk-go-dataplatform/model_lan.go | 212 +++++++++++ .../model_maintenance_window.go | 8 +- .../sdk-go-dataplatform/model_metadata.go | 26 +- .../sdk-go-dataplatform/model_node_pool.go | 26 +- .../model_node_pool_list_response_data.go | 6 +- .../model_node_pool_response_data.go | 6 +- .../model_patch_cluster_properties.go | 50 ++- .../model_patch_cluster_request.go | 6 +- .../model_patch_node_pool_properties.go | 8 +- .../model_patch_node_pool_request.go | 4 +- .../sdk-go-dataplatform/model_route.go | 169 +++++++++ .../sdk-go-dataplatform/model_storage_type.go | 8 +- .../model_versions_get_200_response.go | 253 +++++++++++++ .../sdk-go-dataplatform/response.go | 4 +- .../ionos-cloud/sdk-go-dataplatform/utils.go | 25 +- vendor/modules.txt | 2 +- 44 files changed, 1533 insertions(+), 544 deletions(-) create mode 100644 vendor/github.com/ionos-cloud/sdk-go-dataplatform/.gitbook.yaml create mode 100644 vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_lan.go create mode 100644 vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_route.go create mode 100644 vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_versions_get_200_response.go diff --git a/CHANGELOG.md b/CHANGELOG.md index 1d9ceef34..98743c9e9 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,7 @@ - Fix name validation for Dataplatform resources - Change location for MongoDB tests to improve running time - Change location for PgSQL tests to improve running time +- Add new attribute for Dataplatform clusters: `lans` ## 6.4.14 ### Features diff --git a/docs/data-sources/dataplatform_cluster.md b/docs/data-sources/dataplatform_cluster.md index 433d8679f..909af515c 100644 --- a/docs/data-sources/dataplatform_cluster.md +++ b/docs/data-sources/dataplatform_cluster.md @@ -82,6 +82,12 @@ The following attributes are returned by the datasource: * value - is the token * `server` - cluster server (same as `config[0].clusters[0].cluster.server` but provided as an attribute for ease of use) * `ca_crt` - base64 decoded cluster certificate authority data (provided as an attribute for direct use) +* `lans` - A list of LANs you want this node pool to be part of + * `lan_id` - The LAN ID of an existing LAN at the related data center + * `dhcp` - Indicates if the Kubernetes node pool LAN will reserve an IP using DHCP. The default value is 'true'. + * `routes` - An array of additional LANs attached to worker nodes + * `gateway` - IPv4 or IPv6 gateway IP for the route + * `network` - IPv4 or IPv6 CIDR to be routed via the interface **NOTE**: The whole `config` node is marked as **sensitive**. diff --git a/docs/resources/dataplatform_cluster.md b/docs/resources/dataplatform_cluster.md index 45ed1367b..9042b927e 100644 --- a/docs/resources/dataplatform_cluster.md +++ b/docs/resources/dataplatform_cluster.md @@ -27,7 +27,31 @@ resource "ionoscloud_dataplatform_cluster" "example" { day_of_the_week = "Sunday" time = "09:00:00" } - version = "23.7" + version = "23.11" + lans { + lan_id = + dhcp = false + routes { + network = + gateway = + } + } + lans { + lan_id = + dhcp = false + routes { + network = + gateway = + } + routes { + network = + gateway = + } + routes { + network = + gateway = + } + } } ``` @@ -39,6 +63,12 @@ resource "ionoscloud_dataplatform_cluster" "example" { * `maintenance_window` - (Optional)[string] Starting time of a weekly 4 hour-long window, during which maintenance might occur in hh:mm:ss format * `time` - (Required)[string] Time at which the maintenance should start. Must conform to the 'HH:MM:SS' 24-hour format. This pattern matches the "HH:MM:SS 24-hour format with leading 0" format. For more information take a look at [this link](https://stackoverflow.com/questions/7536755/regular-expression-for-matching-hhmm-time-format). * `day_of_the_week` - (Required)[string] Must be set with one the values `Monday`, `Tuesday`, `Wednesday`, `Thursday`, `Friday`, `Saturday` or `Sunday`. +* `lans` - (Optional)[list] A list of LANs you want this node pool to be part of. + * `lan_id` - (Required)[string] The LAN ID of an existing LAN at the related data center. + * `dhcp` - (Optional)[bool] Indicates if the Kubernetes node pool LAN will reserve an IP using DHCP. The default value is 'true'. + * `routes` - (Optional)[list] An array of additional LANs attached to worker nodes. + * `gateway` - (Required)[string] IPv4 or IPv6 gateway IP for the route. + * `network` - (Required)[string] IPv4 or IPv6 CIDR to be routed via the interface. ## Import diff --git a/go.mod b/go.mod index 8c8b8716e..cf3bc9a10 100644 --- a/go.mod +++ b/go.mod @@ -8,7 +8,7 @@ require ( github.com/iancoleman/strcase v0.3.0 github.com/ionos-cloud/sdk-go-cert-manager v1.0.1 github.com/ionos-cloud/sdk-go-container-registry v1.1.0 - github.com/ionos-cloud/sdk-go-dataplatform v1.0.0 + github.com/ionos-cloud/sdk-go-dataplatform v1.0.3 github.com/ionos-cloud/sdk-go-dbaas-mariadb v1.0.0 github.com/ionos-cloud/sdk-go-dbaas-mongo v1.3.1 github.com/ionos-cloud/sdk-go-dbaas-postgres v1.1.2 diff --git a/go.sum b/go.sum index ab3b99089..fb8df46ad 100644 --- a/go.sum +++ b/go.sum @@ -90,8 +90,8 @@ github.com/ionos-cloud/sdk-go-cert-manager v1.0.1 h1:QGnenRREavvU0ZrXvY4hmCMXRyv github.com/ionos-cloud/sdk-go-cert-manager v1.0.1/go.mod h1:EYDegkY6fUSkx0BL0GpNMpKvp33AId2vTZL44YLPreA= github.com/ionos-cloud/sdk-go-container-registry v1.1.0 h1:H92gzx9oj0vvbozbXwn2RLNEw7++1Ns3Kl9PGrh5Waw= github.com/ionos-cloud/sdk-go-container-registry v1.1.0/go.mod h1:woBP1+A4N0KXiRj9jG4y/hEXgrVjJv0CUlAvc24mCeo= -github.com/ionos-cloud/sdk-go-dataplatform v1.0.0 h1:seX3oHtMmmlmwSCYUUF91Jrx4B/B9tMyNSNkHbjlAxA= -github.com/ionos-cloud/sdk-go-dataplatform v1.0.0/go.mod h1:YitNqq01IAbzMr1GpXIDW1+pvhiY9eUs7/+rB9UitXE= +github.com/ionos-cloud/sdk-go-dataplatform v1.0.3 h1:eaZITgPaLHbK4d/nVaImvP19a5yAumI5hprjM/B1qSE= +github.com/ionos-cloud/sdk-go-dataplatform v1.0.3/go.mod h1:LXJGnUwLLiJhKgApv7TIPGy7WOuGbYIzBPFxGpNfqN0= github.com/ionos-cloud/sdk-go-dbaas-mariadb v1.0.0 h1:zTfeV4lwp7c8xkjoJH50oz96cuaUVgbypbG7U3dVi5c= github.com/ionos-cloud/sdk-go-dbaas-mariadb v1.0.0/go.mod h1:627dsH56YGQD7x0g2FGdVsxNtBySvQ3QU0uG+d6/Evk= github.com/ionos-cloud/sdk-go-dbaas-mongo v1.3.1 h1:+tDoZ8IEPxYwJd6fDIpWksNJs9Zzw7Pu5A39jTew058= diff --git a/ionoscloud/data_source_dataplatform_cluster.go b/ionoscloud/data_source_dataplatform_cluster.go index e6452a0b3..1575f96fe 100644 --- a/ionoscloud/data_source_dataplatform_cluster.go +++ b/ionoscloud/data_source_dataplatform_cluster.go @@ -3,18 +3,20 @@ package ionoscloud import ( "context" "encoding/base64" + "encoding/json" "errors" "fmt" "log" "strings" + "gopkg.in/yaml.v3" + "github.com/hashicorp/terraform-plugin-sdk/v2/diag" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation" dataplatform "github.com/ionos-cloud/sdk-go-dataplatform" "github.com/ionos-cloud/terraform-provider-ionoscloud/v6/services" dataplatformService "github.com/ionos-cloud/terraform-provider-ionoscloud/v6/services/dataplatform" - "gopkg.in/yaml.v3" ) func dataSourceDataplatformCluster() *schema.Resource { @@ -175,6 +177,44 @@ func dataSourceDataplatformCluster() *schema.Resource { Type: schema.TypeString, Computed: true, }, + "lans": { + Type: schema.TypeSet, + Description: "A list of LANs you want this node pool to be part of", + Computed: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "lan_id": { + Type: schema.TypeString, + Description: "The LAN ID of an existing LAN at the related data center", + Computed: true, + }, + "dhcp": { + Type: schema.TypeBool, + Description: "Indicates if the Kubernetes node pool LAN will reserve an IP using DHCP. The default value is 'true'", + Computed: true, + }, + "routes": { + Type: schema.TypeSet, + Description: "An array of additional LANs attached to worker nodes", + Computed: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "network": { + Type: schema.TypeString, + Description: "IPv4 or IPv6 CIDR to be routed via the interface", + Computed: true, + }, + "gateway": { + Type: schema.TypeString, + Description: "IPv4 or IPv6 gateway IP for the route", + Computed: true, + }, + }, + }, + }, + }, + }, + }, }, Timeouts: &resourceDefaultTimeouts, } @@ -267,16 +307,21 @@ func setAdditionalDataplatformClusterData(ctx context.Context, d *schema.Resourc /* get from api and set in schema the kubeconfig*/ if cluster.Id != nil { - kubeConfig, _, err := client.GetClusterKubeConfig(ctx, *cluster.Id) + kubeConfigMap, _, err := client.GetClusterKubeConfig(ctx, *cluster.Id) if err != nil { return fmt.Errorf("an error occurred while fetching the kubernetes config for cluster with ID %s: %w", *cluster.Id, err) } - if err := d.Set("kube_config", kubeConfig); err != nil { + kubeConfig, err := json.Marshal(kubeConfigMap) + if err != nil { + return err + } + kubeConfigString := string(kubeConfig) + if err := d.Set("kube_config", kubeConfigString); err != nil { return err } - if err := setDataplatformConfigData(d, kubeConfig); err != nil { + if err := setDataplatformConfigData(d, kubeConfigString); err != nil { return err } } diff --git a/ionoscloud/resource_dataplatform_cluster.go b/ionoscloud/resource_dataplatform_cluster.go index 156bac4d1..62bb0e7f6 100644 --- a/ionoscloud/resource_dataplatform_cluster.go +++ b/ionoscloud/resource_dataplatform_cluster.go @@ -6,13 +6,14 @@ import ( "log" "regexp" + "github.com/ionos-cloud/terraform-provider-ionoscloud/v6/utils/constant" + "github.com/hashicorp/terraform-plugin-sdk/v2/diag" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" "github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation" "github.com/ionos-cloud/terraform-provider-ionoscloud/v6/services" dataplatformService "github.com/ionos-cloud/terraform-provider-ionoscloud/v6/services/dataplatform" "github.com/ionos-cloud/terraform-provider-ionoscloud/v6/utils" - "github.com/ionos-cloud/terraform-provider-ionoscloud/v6/utils/constant" ) func resourceDataplatformCluster() *schema.Resource { @@ -67,6 +68,47 @@ func resourceDataplatformCluster() *schema.Resource { }, }, }, + "lans": { + Type: schema.TypeSet, + Description: "A list of LANs you want this node pool to be part of", + Optional: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "lan_id": { + Type: schema.TypeString, + Description: "The LAN ID of an existing LAN at the related data center", + Required: true, + }, + "dhcp": { + Type: schema.TypeBool, + Description: "Indicates if the Kubernetes node pool LAN will reserve an IP using DHCP. The default value is 'true'", + Optional: true, + Default: true, + }, + "routes": { + Type: schema.TypeSet, + Description: "An array of additional LANs attached to worker nodes", + Optional: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "network": { + Type: schema.TypeString, + Description: "IPv4 or IPv6 CIDR to be routed via the interface", + ValidateDiagFunc: validation.ToDiagFunc(validation.IsCIDR), + Required: true, + }, + "gateway": { + Type: schema.TypeString, + Description: "IPv4 or IPv6 gateway IP for the route", + ValidateDiagFunc: validation.ToDiagFunc(validation.IsIPAddress), + Required: true, + }, + }, + }, + }, + }, + }, + }, }, Timeouts: &resourceDefaultTimeouts, } diff --git a/services/dataplatform/cluster.go b/services/dataplatform/cluster.go index 52424c954..550bf0feb 100644 --- a/services/dataplatform/cluster.go +++ b/services/dataplatform/cluster.go @@ -28,30 +28,31 @@ func (c *Client) IsClusterReady(ctx context.Context, d *schema.ResourceData) (bo } func (c *Client) GetClusterById(ctx context.Context, id string) (dataplatform.ClusterResponseData, *dataplatform.APIResponse, error) { - cluster, apiResponse, err := c.sdkClient.DataPlatformClusterApi.GetCluster(ctx, id).Execute() + cluster, apiResponse, err := c.sdkClient.DataPlatformClusterApi.ClustersFindById(ctx, id).Execute() apiResponse.LogInfo() return cluster, apiResponse, err } // IsClusterDeleted - checks if resource still exists. To be used with WaitForResourceToBeDeleted func (c *Client) IsClusterDeleted(ctx context.Context, d *schema.ResourceData) (bool, error) { - _, apiResponse, err := c.sdkClient.DataPlatformClusterApi.GetCluster(ctx, d.Id()).Execute() + _, apiResponse, err := c.sdkClient.DataPlatformClusterApi.ClustersFindById(ctx, d.Id()).Execute() apiResponse.LogInfo() return apiResponse.HttpNotFound(), err } -func (c *Client) GetClusterKubeConfig(ctx context.Context, clusterId string) (string, *dataplatform.APIResponse, error) { - kubeConfig, apiResponse, err := c.sdkClient.DataPlatformClusterApi.GetClusterKubeconfig(ctx, clusterId).Execute() +// GetClusterKubeConfig - gets the kube config for the cluster +func (c *Client) GetClusterKubeConfig(ctx context.Context, clusterID string) (map[string]interface{}, *dataplatform.APIResponse, error) { + kubeConfig, apiResponse, err := c.sdkClient.DataPlatformClusterApi.ClustersKubeconfigFindByClusterId(ctx, clusterID).Execute() apiResponse.LogInfo() return kubeConfig, apiResponse, err } func (c *Client) ListClusters(ctx context.Context, filterName string) (dataplatform.ClusterListResponseData, *dataplatform.APIResponse, error) { - request := c.sdkClient.DataPlatformClusterApi.GetClusters(ctx) + request := c.sdkClient.DataPlatformClusterApi.ClustersGet(ctx) if filterName != "" { request = request.Name(filterName) } - clusters, apiResponse, err := c.sdkClient.DataPlatformClusterApi.GetClustersExecute(request) + clusters, apiResponse, err := c.sdkClient.DataPlatformClusterApi.ClustersGetExecute(request) apiResponse.LogInfo() return clusters, apiResponse, err } @@ -60,7 +61,7 @@ func (c *Client) ListClusters(ctx context.Context, filterName string) (dataplatf // the apiResponse, or an error if an error occurred func (c *Client) CreateCluster(ctx context.Context, d *schema.ResourceData) (id string, responseInfo utils.ApiResponseInfo, err error) { createRequest := setCreateClusterRequestProperties(d) - clusterResponse, apiResponse, err := c.sdkClient.DataPlatformClusterApi.CreateCluster(ctx).CreateClusterRequest(*createRequest).Execute() + clusterResponse, apiResponse, err := c.sdkClient.DataPlatformClusterApi.ClustersPost(ctx).CreateClusterRequest(*createRequest).Execute() apiResponse.LogInfo() if err != nil { return "", apiResponse, err @@ -70,13 +71,13 @@ func (c *Client) CreateCluster(ctx context.Context, d *schema.ResourceData) (id func (c *Client) UpdateCluster(ctx context.Context, id string, d *schema.ResourceData) (utils.ApiResponseInfo, error) { cluster := setPatchClusterRequestProperties(d) - _, apiResponse, err := c.sdkClient.DataPlatformClusterApi.PatchCluster(ctx, id).PatchClusterRequest(*cluster).Execute() + _, apiResponse, err := c.sdkClient.DataPlatformClusterApi.ClustersPatch(ctx, id).PatchClusterRequest(*cluster).Execute() apiResponse.LogInfo() return apiResponse, err } func (c *Client) DeleteCluster(ctx context.Context, id string) (utils.ApiResponseInfo, error) { - _, apiResponse, err := c.sdkClient.DataPlatformClusterApi.DeleteCluster(ctx, id).Execute() + _, apiResponse, err := c.sdkClient.DataPlatformClusterApi.ClustersDelete(ctx, id).Execute() apiResponse.LogInfo() return apiResponse, err } @@ -106,6 +107,8 @@ func setCreateClusterRequestProperties(d *schema.ResourceData) *dataplatform.Cre dataplatformCluster.Properties.MaintenanceWindow = setMaintenanceWindowData(d) } + dataplatformCluster.Properties.Lans = setLansData(d) + return &dataplatformCluster } @@ -129,9 +132,48 @@ func setPatchClusterRequestProperties(d *schema.ResourceData) *dataplatform.Patc dataplatformCluster.Properties.MaintenanceWindow = setMaintenanceWindowData(d) } + dataplatformCluster.Properties.Lans = setLansData(d) + return &dataplatformCluster } +func setLansData(d *schema.ResourceData) *[]dataplatform.Lan { + var lansBody []dataplatform.Lan + if lansData, ok := d.GetOk("lans"); ok { + if lansData, ok := lansData.(*schema.Set); ok { + for _, lanData := range lansData.List() { + if lan, ok := lanData.(map[string]interface{}); ok { + lanID := lan["lan_id"].(string) + dhcp := lan["dhcp"].(bool) + var lanBody dataplatform.Lan + lanBody.LanId = &lanID + lanBody.Dhcp = &dhcp + lanBody.Routes = setRoutesData(lan) + lansBody = append(lansBody, lanBody) + } + } + } + } + return &lansBody +} + +func setRoutesData(lan map[string]interface{}) *[]dataplatform.Route { + var routesBody []dataplatform.Route + if routesData, ok := lan["routes"].(*schema.Set); ok { + for _, routeData := range routesData.List() { + if route, ok := routeData.(map[string]interface{}); ok { + network := route["network"].(string) + gateway := route["gateway"].(string) + var routeBody dataplatform.Route + routeBody.Network = &network + routeBody.Gateway = &gateway + routesBody = append(routesBody, routeBody) + } + } + } + return &routesBody +} + func setMaintenanceWindowData(d *schema.ResourceData) *dataplatform.MaintenanceWindow { var maintenanceWindow dataplatform.MaintenanceWindow @@ -181,9 +223,36 @@ func SetDataplatformClusterData(d *schema.ResourceData, cluster dataplatform.Clu } } + if cluster.Properties.Lans != nil { + if err := d.Set("lans", setLansProperties(*cluster.Properties.Lans)); err != nil { + return utils.GenerateSetError(clusterResourceName, "lans", err) + } + } + return nil } +func setLansProperties(retrievedLans []dataplatform.Lan) []interface{} { + lans := make([]interface{}, len(retrievedLans)) + for i, lanElem := range retrievedLans { + lanEntry := make(map[string]interface{}) + utils.SetPropWithNilCheck(lanEntry, "lan_id", lanElem.LanId) + utils.SetPropWithNilCheck(lanEntry, "dhcp", lanElem.Dhcp) + if lanElem.Routes != nil { + routes := make([]interface{}, len(*lanElem.Routes)) + for i, routeElem := range *lanElem.Routes { + routeEntry := make(map[string]interface{}) + utils.SetPropWithNilCheck(routeEntry, "network", routeElem.Network) + utils.SetPropWithNilCheck(routeEntry, "gateway", routeElem.Gateway) + routes[i] = routeEntry + } + utils.SetPropWithNilCheck(lanEntry, "routes", routes) + } + lans[i] = lanEntry + } + return lans +} + func SetMaintenanceWindowProperties(maintenanceWindow dataplatform.MaintenanceWindow) map[string]interface{} { maintenance := map[string]interface{}{} diff --git a/services/dataplatform/nodepool.go b/services/dataplatform/nodepool.go index 14440409e..4e5c68d76 100644 --- a/services/dataplatform/nodepool.go +++ b/services/dataplatform/nodepool.go @@ -18,7 +18,7 @@ import ( var nodePoolResourceName = "Dataplatform Node Pool" func (c *Client) GetNodePool(ctx context.Context, clusterId, nodePoolId string) (dataplatform.NodePoolResponseData, *dataplatform.APIResponse, error) { - cluster, apiResponse, err := c.sdkClient.DataPlatformNodePoolApi.GetClusterNodepool(ctx, clusterId, nodePoolId).Execute() + cluster, apiResponse, err := c.sdkClient.DataPlatformNodePoolApi.ClustersNodepoolsFindById(ctx, clusterId, nodePoolId).Execute() apiResponse.LogInfo() return cluster, apiResponse, err } @@ -30,33 +30,33 @@ func (c *Client) IsNodePoolDeleted(ctx context.Context, d *schema.ResourceData) } clusterIdStr := clusterId.(string) nodePoolId := d.Id() - _, apiResponse, err := c.sdkClient.DataPlatformNodePoolApi.GetClusterNodepool(ctx, clusterIdStr, nodePoolId).Execute() + _, apiResponse, err := c.sdkClient.DataPlatformNodePoolApi.ClustersNodepoolsFindById(ctx, clusterIdStr, nodePoolId).Execute() apiResponse.LogInfo() return apiResponse.HttpNotFound(), err } func (c *Client) ListNodePools(ctx context.Context, clusterId string) (dataplatform.NodePoolListResponseData, *dataplatform.APIResponse, error) { - nodePool, apiResponse, err := c.sdkClient.DataPlatformNodePoolApi.GetClusterNodepools(ctx, clusterId).Execute() + nodePool, apiResponse, err := c.sdkClient.DataPlatformNodePoolApi.ClustersNodepoolsGet(ctx, clusterId).Execute() apiResponse.LogInfo() return nodePool, apiResponse, err } func (c *Client) CreateNodePool(ctx context.Context, clusterId string, d *schema.ResourceData) (dataplatform.NodePoolResponseData, *dataplatform.APIResponse, error) { dataplatformNodePool := GetDataplatformNodePoolDataCreate(d) - clusterResponse, apiResponse, err := c.sdkClient.DataPlatformNodePoolApi.CreateClusterNodepool(ctx, clusterId).CreateNodePoolRequest(*dataplatformNodePool).Execute() + clusterResponse, apiResponse, err := c.sdkClient.DataPlatformNodePoolApi.ClustersNodepoolsPost(ctx, clusterId).CreateNodePoolRequest(*dataplatformNodePool).Execute() apiResponse.LogInfo() return clusterResponse, apiResponse, err } func (c *Client) UpdateNodePool(ctx context.Context, clusterId, nodePoolId string, d *schema.ResourceData) (dataplatform.NodePoolResponseData, utils.ApiResponseInfo, error) { dataplatformNodePool := GetDataplatformNodePoolDataUpdate(d) - clusterResponse, apiResponse, err := c.sdkClient.DataPlatformNodePoolApi.PatchClusterNodepool(ctx, clusterId, nodePoolId).PatchNodePoolRequest(*dataplatformNodePool).Execute() + clusterResponse, apiResponse, err := c.sdkClient.DataPlatformNodePoolApi.ClustersNodepoolsPatch(ctx, clusterId, nodePoolId).PatchNodePoolRequest(*dataplatformNodePool).Execute() apiResponse.LogInfo() return clusterResponse, apiResponse, err } func (c *Client) DeleteNodePool(ctx context.Context, clusterId, nodePoolId string) (dataplatform.NodePoolResponseData, *dataplatform.APIResponse, error) { - clusterResponse, apiResponse, err := c.sdkClient.DataPlatformNodePoolApi.DeleteClusterNodepool(ctx, clusterId, nodePoolId).Execute() + clusterResponse, apiResponse, err := c.sdkClient.DataPlatformNodePoolApi.ClustersNodepoolsDelete(ctx, clusterId, nodePoolId).Execute() apiResponse.LogInfo() return clusterResponse, apiResponse, err } diff --git a/services/dataplatform/versions.go b/services/dataplatform/versions.go index 3cb918513..883ac0c15 100644 --- a/services/dataplatform/versions.go +++ b/services/dataplatform/versions.go @@ -13,7 +13,13 @@ import ( func (c *Client) GetVersions(ctx context.Context) ([]string, *dataplatform.APIResponse, error) { versions, apiResponse, err := c.sdkClient.DataPlatformMetaDataApi.VersionsGet(ctx).Execute() apiResponse.LogInfo() - return versions, apiResponse, err + if err != nil { + return nil, apiResponse, err + } + if versions.Items == nil { + return nil, nil, fmt.Errorf("expected a list of Dataplatform versions but received 'nil' instead") + } + return *versions.Items, apiResponse, err } func SetVersionsData(d *schema.ResourceData, versions []string) diag.Diagnostics { diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/.gitbook.yaml b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/.gitbook.yaml new file mode 100644 index 000000000..6c8fbd82b --- /dev/null +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/.gitbook.yaml @@ -0,0 +1,4 @@ +root: docs +structure: + readme: README.md + summary: summary.md diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/README.md b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/README.md index f37f72758..1a93f37f4 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/README.md +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/README.md @@ -1,12 +1,12 @@ # Go API client for ionoscloud -Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster +*Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly -and build his desired application on top of the Stackable Platform. +and build his desired application on top of the Stackable platform. -Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API -in addition or as an alternative to the \"Data Center Designer\" (DCD). +The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API +in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started @@ -16,32 +16,34 @@ To get your DataPlatformCluster up and running, the following steps needs to be The first step is the creation of a IONOS Cloud account if not already existing. -To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). +To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). -### Virtual Datacenter (VDC) +### Virtual Data Center (VDC) -The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. -This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform -to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in -a new VDC or you have not yet created a VDC, you need to do so. +The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. +This could either be a VDC that already exists, especially if you want to connect the managed data platform +to other services already running within your VDC. +Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, +you need to do so. -A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. -For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) +A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. +For more information, see the +[official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. -This token can be generated using the IONOS-CLI the following way: +This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` -For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) +For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster -Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. +Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. @@ -53,7 +55,7 @@ that was presented to you in the response of the create cluster call. To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. -You may create further node pools with resources tailored to your use-case. +You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. @@ -63,14 +65,24 @@ endpoint. Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. +To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration +rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. + +If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. +This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details +[here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). + The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. -### Create Stackable Service +### Create Stackable Services -To create the desired application, the Stackable service needs to be provided, -using the received kubeconfig and -[deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) +You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the +deployment of [Stackable data apps](https://stackable.tech/en/platform/). + +With the Stackable operators, you can deploy the +[data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) +you want in your Data Platform cluster. ## Authorization @@ -78,22 +90,22 @@ All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). -### Basic-Auth - -The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header -accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) +### Basic Auth -### API-Key as Bearer Token +The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header +accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). -The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. -(See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) -For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. +### API Key as Bearer Token -### Permissions and access roles +The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI +(For details, see the +[documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). +For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. -Currently, an admin can see and manipulate all resources in a contract. -A normal authenticated user can only see and manipulate resources he created. +### Permissions and Access Roles +Currently, an administrator can see and manipulate all resources in a contract. +Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components @@ -102,12 +114,15 @@ The concept of a DataPlatformClusters and the backing DataPlatformNodePools the ### DataPlatformCluster -A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. +A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services +like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. -Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. -to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. +Therefore, it's possible to integrate the cluster with other resources as VLANs +e.g. to shape the data center in the customer's need +and integrate the cluster within the topology the customer wants to build. -In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. +In addition to the Kubernetes cluster, a small node pool is provided +which is exclusively used to run the Stackable operators. ### DataPlatformNodePool @@ -116,19 +131,19 @@ All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. -Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC +Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. -### References +## References ## Overview This API client was generated by the [OpenAPI Generator](https://openapi-generator.tech) project. By using the [OpenAPI-spec](https://www.openapis.org/) from a remote server, you can easily generate an API client. -- API version: 0.0.7 -- Package version: 1.0.0 +- API version: 1.1.0 +- Package version: 1.0.3 - Build package: org.openapitools.codegen.languages.GoClientCodegen -For more information, please visit [https://ionos.com](https://ionos.com) +For more information, please visit [https://www.ionos.com](https://www.ionos.com) ## Installation @@ -136,14 +151,13 @@ Install the following dependencies: ```shell go get github.com/stretchr/testify/assert -go get golang.org/x/oauth2 go get golang.org/x/net/context ``` Put the package under your project folder and add the following in import: ```golang -import sw "./ionoscloud" +import ionoscloud "github.com/ionos-cloud/sdk-go-dataplatform" ``` To use a proxy, set the environment variable `HTTP_PROXY`: @@ -161,7 +175,7 @@ Default configuration comes with `Servers` field that contains server objects as For using other server than the one defined on index 0 set context value `sw.ContextServerIndex` of type `int`. ```golang -ctx := context.WithValue(context.Background(), sw.ContextServerIndex, 1) +ctx := context.WithValue(context.Background(), ionoscloud.ContextServerIndex, 1) ``` ### Templated Server URL @@ -169,48 +183,31 @@ ctx := context.WithValue(context.Background(), sw.ContextServerIndex, 1) Templated server URL is formatted using default variables from configuration or from context value `sw.ContextServerVariables` of type `map[string]string`. ```golang -ctx := context.WithValue(context.Background(), sw.ContextServerVariables, map[string]string{ +ctx := context.WithValue(context.Background(), ionoscloud.ContextServerVariables, map[string]string{ "basePath": "v2", }) ``` Note, enum values are always validated and all unused variables are silently ignored. -### URLs Configuration per Operation - -Each operation can use different server URL defined using `OperationServers` map in the `Configuration`. -An operation is uniquely identifield by `"{classname}Service.{nickname}"` string. -Similar rules for overriding default operation server index and variables applies by using `sw.ContextOperationServerIndices` and `sw.ContextOperationServerVariables` context maps. - -``` -ctx := context.WithValue(context.Background(), sw.ContextOperationServerIndices, map[string]int{ - "{classname}Service.{nickname}": 2, -}) -ctx = context.WithValue(context.Background(), sw.ContextOperationServerVariables, map[string]map[string]string{ - "{classname}Service.{nickname}": { - "port": "8443", - }, -}) -``` - ## Documentation for API Endpoints All URIs are relative to *https://api.ionos.com/dataplatform* Class | Method | HTTP request | Description ------------ | ------------- | ------------- | ------------- -*DataPlatformClusterApi* | [**CreateCluster**](docs/api/DataPlatformClusterApi.md#createcluster) | **Post** /clusters | Create a DataPlatformCluster -*DataPlatformClusterApi* | [**DeleteCluster**](docs/api/DataPlatformClusterApi.md#deletecluster) | **Delete** /clusters/{clusterId} | Delete DataPlatformCluster -*DataPlatformClusterApi* | [**GetCluster**](docs/api/DataPlatformClusterApi.md#getcluster) | **Get** /clusters/{clusterId} | Retrieve a DataPlatformCluster -*DataPlatformClusterApi* | [**GetClusterKubeconfig**](docs/api/DataPlatformClusterApi.md#getclusterkubeconfig) | **Get** /clusters/{clusterId}/kubeconfig | Read the kubeconfig -*DataPlatformClusterApi* | [**GetClusters**](docs/api/DataPlatformClusterApi.md#getclusters) | **Get** /clusters | List DataPlatformCluster -*DataPlatformClusterApi* | [**PatchCluster**](docs/api/DataPlatformClusterApi.md#patchcluster) | **Patch** /clusters/{clusterId} | Partially modify a DataPlatformCluster -*DataPlatformMetaDataApi* | [**VersionsGet**](docs/api/DataPlatformMetaDataApi.md#versionsget) | **Get** /versions | Managed Data Stack API version -*DataPlatformNodePoolApi* | [**CreateClusterNodepool**](docs/api/DataPlatformNodePoolApi.md#createclusternodepool) | **Post** /clusters/{clusterId}/nodepools | Create a DataPlatformNodePool for a distinct DataPlatformCluster -*DataPlatformNodePoolApi* | [**DeleteClusterNodepool**](docs/api/DataPlatformNodePoolApi.md#deleteclusternodepool) | **Delete** /clusters/{clusterId}/nodepools/{nodepoolId} | Remove node pool from DataPlatformCluster. -*DataPlatformNodePoolApi* | [**GetClusterNodepool**](docs/api/DataPlatformNodePoolApi.md#getclusternodepool) | **Get** /clusters/{clusterId}/nodepools/{nodepoolId} | Retrieve a DataPlatformNodePool -*DataPlatformNodePoolApi* | [**GetClusterNodepools**](docs/api/DataPlatformNodePoolApi.md#getclusternodepools) | **Get** /clusters/{clusterId}/nodepools | List the DataPlatformNodePools of a DataPlatformCluster -*DataPlatformNodePoolApi* | [**PatchClusterNodepool**](docs/api/DataPlatformNodePoolApi.md#patchclusternodepool) | **Patch** /clusters/{clusterId}/nodepools/{nodepoolId} | Partially modify a DataPlatformNodePool +*DataPlatformClusterApi* | [**ClustersDelete**](docs/api/DataPlatformClusterApi.md#clustersdelete) | **Delete** /clusters/{clusterId} | Delete a DataPlatformCluster +*DataPlatformClusterApi* | [**ClustersFindById**](docs/api/DataPlatformClusterApi.md#clustersfindbyid) | **Get** /clusters/{clusterId} | Retrieve a DataPlatformCluster +*DataPlatformClusterApi* | [**ClustersGet**](docs/api/DataPlatformClusterApi.md#clustersget) | **Get** /clusters | List the DataPlatformClusters +*DataPlatformClusterApi* | [**ClustersKubeconfigFindByClusterId**](docs/api/DataPlatformClusterApi.md#clusterskubeconfigfindbyclusterid) | **Get** /clusters/{clusterId}/kubeconfig | Read the Kubeconfig +*DataPlatformClusterApi* | [**ClustersPatch**](docs/api/DataPlatformClusterApi.md#clusterspatch) | **Patch** /clusters/{clusterId} | Partially Modify a DataPlatformCluster +*DataPlatformClusterApi* | [**ClustersPost**](docs/api/DataPlatformClusterApi.md#clusterspost) | **Post** /clusters | Create a DataPlatformCluster +*DataPlatformMetaDataApi* | [**VersionsGet**](docs/api/DataPlatformMetaDataApi.md#versionsget) | **Get** /versions | Managed Stackable Data Platform API Versions +*DataPlatformNodePoolApi* | [**ClustersNodepoolsDelete**](docs/api/DataPlatformNodePoolApi.md#clustersnodepoolsdelete) | **Delete** /clusters/{clusterId}/nodepools/{nodepoolId} | Remove a DataPlatformNodePool from a DataPlatformCluster +*DataPlatformNodePoolApi* | [**ClustersNodepoolsFindById**](docs/api/DataPlatformNodePoolApi.md#clustersnodepoolsfindbyid) | **Get** /clusters/{clusterId}/nodepools/{nodepoolId} | Retrieve a DataPlatformNodePool +*DataPlatformNodePoolApi* | [**ClustersNodepoolsGet**](docs/api/DataPlatformNodePoolApi.md#clustersnodepoolsget) | **Get** /clusters/{clusterId}/nodepools | List the DataPlatformNodePools of a DataPlatformCluster +*DataPlatformNodePoolApi* | [**ClustersNodepoolsPatch**](docs/api/DataPlatformNodePoolApi.md#clustersnodepoolspatch) | **Patch** /clusters/{clusterId}/nodepools/{nodepoolId} | Partially Modify a DataPlatformNodePool +*DataPlatformNodePoolApi* | [**ClustersNodepoolsPost**](docs/api/DataPlatformNodePoolApi.md#clustersnodepoolspost) | **Post** /clusters/{clusterId}/nodepools | Create a DataPlatformNodePool for a distinct DataPlatformCluster ## Documentation For Models @@ -225,6 +222,7 @@ Class | Method | HTTP request | Description - [CreateNodePoolRequest](docs/models/CreateNodePoolRequest.md) - [ErrorMessage](docs/models/ErrorMessage.md) - [ErrorResponse](docs/models/ErrorResponse.md) + - [Lan](docs/models/Lan.md) - [MaintenanceWindow](docs/models/MaintenanceWindow.md) - [Metadata](docs/models/Metadata.md) - [NodePool](docs/models/NodePool.md) @@ -234,36 +232,37 @@ Class | Method | HTTP request | Description - [PatchClusterRequest](docs/models/PatchClusterRequest.md) - [PatchNodePoolProperties](docs/models/PatchNodePoolProperties.md) - [PatchNodePoolRequest](docs/models/PatchNodePoolRequest.md) + - [Route](docs/models/Route.md) - [StorageType](docs/models/StorageType.md) + - [VersionsGet200Response](docs/models/VersionsGet200Response.md) ## Documentation For Authorization +Authentication schemes defined for the API: +### tokenAuth -### basicAuth - -- **Type**: HTTP basic authentication +- **Type**: HTTP Bearer token authentication Example ```golang -auth := context.WithValue(context.Background(), sw.ContextBasicAuth, sw.BasicAuth{ - UserName: "username", - Password: "password", -}) +auth := context.WithValue(context.Background(), sw.ContextAccessToken, "BEARER_TOKEN_STRING") r, err := client.Service.Operation(auth, args) ``` +### basicAuth -### tokenAuth - -- **Type**: HTTP Bearer token authentication +- **Type**: HTTP basic authentication Example ```golang -auth := context.WithValue(context.Background(), sw.ContextAccessToken, "BEARERTOKENSTRING") +auth := context.WithValue(context.Background(), sw.ContextBasicAuth, sw.BasicAuth{ + UserName: "username", + Password: "password", +}) r, err := client.Service.Operation(auth, args) ``` diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/api_data_platform_cluster.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/api_data_platform_cluster.go index 912de8f1f..992588864 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/api_data_platform_cluster.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/api_data_platform_cluster.go @@ -1,9 +1,9 @@ /* * IONOS Cloud - Managed Stackable Data Platform API * - * Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable Platform. Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the \"Data Center Designer\" (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Datacenter (VDC) The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS-CLI the following way: ``` ionosctl token generate ``` For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) ### Create a new DataPlatformCluster Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use-case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Service To create the desired application, the Stackable service needs to be provided, using the received kubeconfig and [deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic-Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) ### API-Key as Bearer Token The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. (See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. ### Permissions and access roles Currently, an admin can see and manipulate all resources in a contract. A normal authenticated user can only see and manipulate resources he created. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC and can only be modified or deleted via the API. ### References + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References * - * API version: 0.0.7 + * API version: 1.1.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -13,7 +13,7 @@ package ionoscloud import ( _context "context" "fmt" - _ioutil "io/ioutil" + "io" _nethttp "net/http" _neturl "net/url" "strings" @@ -27,37 +27,32 @@ var ( // DataPlatformClusterApiService DataPlatformClusterApi service type DataPlatformClusterApiService service -type ApiCreateClusterRequest struct { - ctx _context.Context - ApiService *DataPlatformClusterApiService - createClusterRequest *CreateClusterRequest -} - -func (r ApiCreateClusterRequest) CreateClusterRequest(createClusterRequest CreateClusterRequest) ApiCreateClusterRequest { - r.createClusterRequest = &createClusterRequest - return r +type ApiClustersDeleteRequest struct { + ctx _context.Context + ApiService *DataPlatformClusterApiService + clusterId string } -func (r ApiCreateClusterRequest) Execute() (ClusterResponseData, *APIResponse, error) { - return r.ApiService.CreateClusterExecute(r) +func (r ApiClustersDeleteRequest) Execute() (ClusterResponseData, *APIResponse, error) { + return r.ApiService.ClustersDeleteExecute(r) } /* - - CreateCluster Create a DataPlatformCluster - - Creates a new DataPlatformCluster. - -The cluster will be provisioned in the datacenter matching the provided `datacenterID`. -Therefore the datacenter must be created upfront and must be accessible by the user issuing the request. + - ClustersDelete Delete a DataPlatformCluster + - Deletes the specified DataPlatformCluster by its distinct cluster ID. -To create a new virtual datacenter (VDC) [see](https://api.ionos.com/docs/cloud/v6/#Data-centers-post-datacenters). +The ID can be found in the response when a cluster is created +or when you GET a list of all DataPlatformClusters. - @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). - - @return ApiCreateClusterRequest + - @param clusterId The unique ID of the cluster. Must conform to the UUID format. + - @return ApiClustersDeleteRequest */ -func (a *DataPlatformClusterApiService) CreateCluster(ctx _context.Context) ApiCreateClusterRequest { - return ApiCreateClusterRequest{ +func (a *DataPlatformClusterApiService) ClustersDelete(ctx _context.Context, clusterId string) ApiClustersDeleteRequest { + return ApiClustersDeleteRequest{ ApiService: a, ctx: ctx, + clusterId: clusterId, } } @@ -65,9 +60,9 @@ func (a *DataPlatformClusterApiService) CreateCluster(ctx _context.Context) ApiC * Execute executes the request * @return ClusterResponseData */ -func (a *DataPlatformClusterApiService) CreateClusterExecute(r ApiCreateClusterRequest) (ClusterResponseData, *APIResponse, error) { +func (a *DataPlatformClusterApiService) ClustersDeleteExecute(r ApiClustersDeleteRequest) (ClusterResponseData, *APIResponse, error) { var ( - localVarHTTPMethod = _nethttp.MethodPost + localVarHTTPMethod = _nethttp.MethodDelete localVarPostBody interface{} localVarFormFileName string localVarFileName string @@ -75,22 +70,26 @@ func (a *DataPlatformClusterApiService) CreateClusterExecute(r ApiCreateClusterR localVarReturnValue ClusterResponseData ) - localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DataPlatformClusterApiService.CreateCluster") + localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DataPlatformClusterApiService.ClustersDelete") if err != nil { return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()} } - localVarPath := localBasePath + "/clusters" + localVarPath := localBasePath + "/clusters/{clusterId}" + localVarPath = strings.Replace(localVarPath, "{"+"clusterId"+"}", _neturl.PathEscape(parameterToString(r.clusterId, "")), -1) localVarHeaderParams := make(map[string]string) localVarQueryParams := _neturl.Values{} localVarFormParams := _neturl.Values{} - if r.createClusterRequest == nil { - return localVarReturnValue, nil, reportError("createClusterRequest is required and must be specified") + if strlen(r.clusterId) < 32 { + return localVarReturnValue, nil, reportError("clusterId must have at least 32 elements") + } + if strlen(r.clusterId) > 36 { + return localVarReturnValue, nil, reportError("clusterId must have less than 36 elements") } // to determine the Content-Type header - localVarHTTPContentTypes := []string{"application/json"} + localVarHTTPContentTypes := []string{} // set Content-Type header localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes) @@ -106,8 +105,6 @@ func (a *DataPlatformClusterApiService) CreateClusterExecute(r ApiCreateClusterR if localVarHTTPHeaderAccept != "" { localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept } - // body params - localVarPostBody = r.createClusterRequest req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) if err != nil { return localVarReturnValue, nil, err @@ -120,14 +117,14 @@ func (a *DataPlatformClusterApiService) CreateClusterExecute(r ApiCreateClusterR Method: localVarHTTPMethod, RequestTime: httpRequestTime, RequestURL: localVarPath, - Operation: "CreateCluster", + Operation: "ClustersDelete", } if err != nil || localVarHTTPResponse == nil { return localVarReturnValue, localVarAPIResponse, err } - localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) + localVarBody, err := io.ReadAll(localVarHTTPResponse.Body) localVarHTTPResponse.Body.Close() localVarAPIResponse.Payload = localVarBody if err != nil { @@ -167,6 +164,15 @@ func (a *DataPlatformClusterApiService) CreateClusterExecute(r ApiCreateClusterR } newErr.model = v } + if localVarHTTPResponse.StatusCode == 404 { + var v ErrorResponse + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.error = err.Error() + return localVarReturnValue, localVarAPIResponse, newErr + } + newErr.model = v + } if localVarHTTPResponse.StatusCode == 500 { var v ErrorResponse err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) @@ -192,29 +198,29 @@ func (a *DataPlatformClusterApiService) CreateClusterExecute(r ApiCreateClusterR return localVarReturnValue, localVarAPIResponse, nil } -type ApiDeleteClusterRequest struct { +type ApiClustersFindByIdRequest struct { ctx _context.Context ApiService *DataPlatformClusterApiService clusterId string } -func (r ApiDeleteClusterRequest) Execute() (ClusterResponseData, *APIResponse, error) { - return r.ApiService.DeleteClusterExecute(r) +func (r ApiClustersFindByIdRequest) Execute() (ClusterResponseData, *APIResponse, error) { + return r.ApiService.ClustersFindByIdExecute(r) } /* - - DeleteCluster Delete DataPlatformCluster - - Deletes the specified DataPlatformCluster by its distinct cluster ID. + - ClustersFindById Retrieve a DataPlatformCluster + - Retrieve the specified DataPlatformCluster by its distinct ID. -The ID can be found in the response when a cluster is created +The cluster ID can be found in the response when a cluster is created or when you GET a list of all DataPlatformClusters. - @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). - @param clusterId The unique ID of the cluster. Must conform to the UUID format. - - @return ApiDeleteClusterRequest + - @return ApiClustersFindByIdRequest */ -func (a *DataPlatformClusterApiService) DeleteCluster(ctx _context.Context, clusterId string) ApiDeleteClusterRequest { - return ApiDeleteClusterRequest{ +func (a *DataPlatformClusterApiService) ClustersFindById(ctx _context.Context, clusterId string) ApiClustersFindByIdRequest { + return ApiClustersFindByIdRequest{ ApiService: a, ctx: ctx, clusterId: clusterId, @@ -225,9 +231,9 @@ func (a *DataPlatformClusterApiService) DeleteCluster(ctx _context.Context, clus * Execute executes the request * @return ClusterResponseData */ -func (a *DataPlatformClusterApiService) DeleteClusterExecute(r ApiDeleteClusterRequest) (ClusterResponseData, *APIResponse, error) { +func (a *DataPlatformClusterApiService) ClustersFindByIdExecute(r ApiClustersFindByIdRequest) (ClusterResponseData, *APIResponse, error) { var ( - localVarHTTPMethod = _nethttp.MethodDelete + localVarHTTPMethod = _nethttp.MethodGet localVarPostBody interface{} localVarFormFileName string localVarFileName string @@ -235,7 +241,7 @@ func (a *DataPlatformClusterApiService) DeleteClusterExecute(r ApiDeleteClusterR localVarReturnValue ClusterResponseData ) - localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DataPlatformClusterApiService.DeleteCluster") + localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DataPlatformClusterApiService.ClustersFindById") if err != nil { return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()} } @@ -282,14 +288,14 @@ func (a *DataPlatformClusterApiService) DeleteClusterExecute(r ApiDeleteClusterR Method: localVarHTTPMethod, RequestTime: httpRequestTime, RequestURL: localVarPath, - Operation: "DeleteCluster", + Operation: "ClustersFindById", } if err != nil || localVarHTTPResponse == nil { return localVarReturnValue, localVarAPIResponse, err } - localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) + localVarBody, err := io.ReadAll(localVarHTTPResponse.Body) localVarHTTPResponse.Body.Close() localVarAPIResponse.Payload = localVarBody if err != nil { @@ -363,67 +369,66 @@ func (a *DataPlatformClusterApiService) DeleteClusterExecute(r ApiDeleteClusterR return localVarReturnValue, localVarAPIResponse, nil } -type ApiGetClusterRequest struct { +type ApiClustersGetRequest struct { ctx _context.Context ApiService *DataPlatformClusterApiService - clusterId string + name *string +} + +func (r ApiClustersGetRequest) Name(name string) ApiClustersGetRequest { + r.name = &name + return r } -func (r ApiGetClusterRequest) Execute() (ClusterResponseData, *APIResponse, error) { - return r.ApiService.GetClusterExecute(r) +func (r ApiClustersGetRequest) Execute() (ClusterListResponseData, *APIResponse, error) { + return r.ApiService.ClustersGetExecute(r) } /* - - GetCluster Retrieve a DataPlatformCluster - - Retrieve the specified DataPlatformCluster by its distinct ID. + - ClustersGet List the DataPlatformClusters + - List all available DataPlatformClusters that can be accessed by the user. -The cluster ID can be found in the response when a cluster is created -or when you GET a list of all DataPlatformClusters. +The user might filter the request for the name of the DataPlatformCluster. +If no cluster is available matching the request, the list will be empty. - @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). - - @param clusterId The unique ID of the cluster. Must conform to the UUID format. - - @return ApiGetClusterRequest + - @return ApiClustersGetRequest */ -func (a *DataPlatformClusterApiService) GetCluster(ctx _context.Context, clusterId string) ApiGetClusterRequest { - return ApiGetClusterRequest{ +func (a *DataPlatformClusterApiService) ClustersGet(ctx _context.Context) ApiClustersGetRequest { + return ApiClustersGetRequest{ ApiService: a, ctx: ctx, - clusterId: clusterId, } } /* * Execute executes the request - * @return ClusterResponseData + * @return ClusterListResponseData */ -func (a *DataPlatformClusterApiService) GetClusterExecute(r ApiGetClusterRequest) (ClusterResponseData, *APIResponse, error) { +func (a *DataPlatformClusterApiService) ClustersGetExecute(r ApiClustersGetRequest) (ClusterListResponseData, *APIResponse, error) { var ( localVarHTTPMethod = _nethttp.MethodGet localVarPostBody interface{} localVarFormFileName string localVarFileName string localVarFileBytes []byte - localVarReturnValue ClusterResponseData + localVarReturnValue ClusterListResponseData ) - localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DataPlatformClusterApiService.GetCluster") + localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DataPlatformClusterApiService.ClustersGet") if err != nil { return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()} } - localVarPath := localBasePath + "/clusters/{clusterId}" - localVarPath = strings.Replace(localVarPath, "{"+"clusterId"+"}", _neturl.PathEscape(parameterToString(r.clusterId, "")), -1) + localVarPath := localBasePath + "/clusters" localVarHeaderParams := make(map[string]string) localVarQueryParams := _neturl.Values{} localVarFormParams := _neturl.Values{} - if strlen(r.clusterId) < 32 { - return localVarReturnValue, nil, reportError("clusterId must have at least 32 elements") - } - if strlen(r.clusterId) > 36 { - return localVarReturnValue, nil, reportError("clusterId must have less than 36 elements") - } + if r.name != nil { + localVarQueryParams.Add("name", parameterToString(*r.name, "")) + } // to determine the Content-Type header localVarHTTPContentTypes := []string{} @@ -453,14 +458,14 @@ func (a *DataPlatformClusterApiService) GetClusterExecute(r ApiGetClusterRequest Method: localVarHTTPMethod, RequestTime: httpRequestTime, RequestURL: localVarPath, - Operation: "GetCluster", + Operation: "ClustersGet", } if err != nil || localVarHTTPResponse == nil { return localVarReturnValue, localVarAPIResponse, err } - localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) + localVarBody, err := io.ReadAll(localVarHTTPResponse.Body) localVarHTTPResponse.Body.Close() localVarAPIResponse.Payload = localVarBody if err != nil { @@ -500,15 +505,6 @@ func (a *DataPlatformClusterApiService) GetClusterExecute(r ApiGetClusterRequest } newErr.model = v } - if localVarHTTPResponse.StatusCode == 404 { - var v ErrorResponse - err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) - if err != nil { - newErr.error = err.Error() - return localVarReturnValue, localVarAPIResponse, newErr - } - newErr.model = v - } if localVarHTTPResponse.StatusCode == 500 { var v ErrorResponse err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) @@ -534,19 +530,19 @@ func (a *DataPlatformClusterApiService) GetClusterExecute(r ApiGetClusterRequest return localVarReturnValue, localVarAPIResponse, nil } -type ApiGetClusterKubeconfigRequest struct { +type ApiClustersKubeconfigFindByClusterIdRequest struct { ctx _context.Context ApiService *DataPlatformClusterApiService clusterId string } -func (r ApiGetClusterKubeconfigRequest) Execute() (string, *APIResponse, error) { - return r.ApiService.GetClusterKubeconfigExecute(r) +func (r ApiClustersKubeconfigFindByClusterIdRequest) Execute() (map[string]interface{}, *APIResponse, error) { + return r.ApiService.ClustersKubeconfigFindByClusterIdExecute(r) } /* - - GetClusterKubeconfig Read the kubeconfig - - Retrieves the Kubernetes configuration file (kubeconfig) + - ClustersKubeconfigFindByClusterId Read the Kubeconfig + - Retrieves the Kubernetes configuration file (*kubeconfig*) for the specified DataPlatformCluster by its cluster ID. @@ -555,10 +551,10 @@ or when you GET a list of all DataPlatformClusters. - @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). - @param clusterId The unique ID of the cluster. Must conform to the UUID format. - - @return ApiGetClusterKubeconfigRequest + - @return ApiClustersKubeconfigFindByClusterIdRequest */ -func (a *DataPlatformClusterApiService) GetClusterKubeconfig(ctx _context.Context, clusterId string) ApiGetClusterKubeconfigRequest { - return ApiGetClusterKubeconfigRequest{ +func (a *DataPlatformClusterApiService) ClustersKubeconfigFindByClusterId(ctx _context.Context, clusterId string) ApiClustersKubeconfigFindByClusterIdRequest { + return ApiClustersKubeconfigFindByClusterIdRequest{ ApiService: a, ctx: ctx, clusterId: clusterId, @@ -567,19 +563,19 @@ func (a *DataPlatformClusterApiService) GetClusterKubeconfig(ctx _context.Contex /* * Execute executes the request - * @return string + * @return map[string]interface{} */ -func (a *DataPlatformClusterApiService) GetClusterKubeconfigExecute(r ApiGetClusterKubeconfigRequest) (string, *APIResponse, error) { +func (a *DataPlatformClusterApiService) ClustersKubeconfigFindByClusterIdExecute(r ApiClustersKubeconfigFindByClusterIdRequest) (map[string]interface{}, *APIResponse, error) { var ( localVarHTTPMethod = _nethttp.MethodGet localVarPostBody interface{} localVarFormFileName string localVarFileName string localVarFileBytes []byte - localVarReturnValue string + localVarReturnValue map[string]interface{} ) - localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DataPlatformClusterApiService.GetClusterKubeconfig") + localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DataPlatformClusterApiService.ClustersKubeconfigFindByClusterId") if err != nil { return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()} } @@ -626,14 +622,14 @@ func (a *DataPlatformClusterApiService) GetClusterKubeconfigExecute(r ApiGetClus Method: localVarHTTPMethod, RequestTime: httpRequestTime, RequestURL: localVarPath, - Operation: "GetClusterKubeconfig", + Operation: "ClustersKubeconfigFindByClusterId", } if err != nil || localVarHTTPResponse == nil { return localVarReturnValue, localVarAPIResponse, err } - localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) + localVarBody, err := io.ReadAll(localVarHTTPResponse.Body) localVarHTTPResponse.Body.Close() localVarAPIResponse.Payload = localVarBody if err != nil { @@ -707,68 +703,82 @@ func (a *DataPlatformClusterApiService) GetClusterKubeconfigExecute(r ApiGetClus return localVarReturnValue, localVarAPIResponse, nil } -type ApiGetClustersRequest struct { - ctx _context.Context - ApiService *DataPlatformClusterApiService - name *string +type ApiClustersPatchRequest struct { + ctx _context.Context + ApiService *DataPlatformClusterApiService + clusterId string + patchClusterRequest *PatchClusterRequest } -func (r ApiGetClustersRequest) Name(name string) ApiGetClustersRequest { - r.name = &name +func (r ApiClustersPatchRequest) PatchClusterRequest(patchClusterRequest PatchClusterRequest) ApiClustersPatchRequest { + r.patchClusterRequest = &patchClusterRequest return r } -func (r ApiGetClustersRequest) Execute() (ClusterListResponseData, *APIResponse, error) { - return r.ApiService.GetClustersExecute(r) +func (r ApiClustersPatchRequest) Execute() (ClusterResponseData, *APIResponse, error) { + return r.ApiService.ClustersPatchExecute(r) } /* - - GetClusters List DataPlatformCluster - - List all available DataPlatformCluster that can be accessed by the user. + - ClustersPatch Partially Modify a DataPlatformCluster + - Modifies the specified DataPlatformCluster by its distinct cluster ID. -The user might filter the request for the name of the DataPlatformCluster. -If no cluster is available matching the request, the list will be empty. +The fields in the request body are applied to the cluster. +Note that the application to the cluster itself is performed asynchronously. +You can check the sync state by querying the cluster with the GET method. + +The ID can be found in the response when a cluster is created +or when you GET a list of all DataPlatformClusters. - @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). - - @return ApiGetClustersRequest + - @param clusterId The unique ID of the cluster. Must conform to the UUID format. + - @return ApiClustersPatchRequest */ -func (a *DataPlatformClusterApiService) GetClusters(ctx _context.Context) ApiGetClustersRequest { - return ApiGetClustersRequest{ +func (a *DataPlatformClusterApiService) ClustersPatch(ctx _context.Context, clusterId string) ApiClustersPatchRequest { + return ApiClustersPatchRequest{ ApiService: a, ctx: ctx, + clusterId: clusterId, } } /* * Execute executes the request - * @return ClusterListResponseData + * @return ClusterResponseData */ -func (a *DataPlatformClusterApiService) GetClustersExecute(r ApiGetClustersRequest) (ClusterListResponseData, *APIResponse, error) { +func (a *DataPlatformClusterApiService) ClustersPatchExecute(r ApiClustersPatchRequest) (ClusterResponseData, *APIResponse, error) { var ( - localVarHTTPMethod = _nethttp.MethodGet + localVarHTTPMethod = _nethttp.MethodPatch localVarPostBody interface{} localVarFormFileName string localVarFileName string localVarFileBytes []byte - localVarReturnValue ClusterListResponseData + localVarReturnValue ClusterResponseData ) - localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DataPlatformClusterApiService.GetClusters") + localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DataPlatformClusterApiService.ClustersPatch") if err != nil { return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()} } - localVarPath := localBasePath + "/clusters" + localVarPath := localBasePath + "/clusters/{clusterId}" + localVarPath = strings.Replace(localVarPath, "{"+"clusterId"+"}", _neturl.PathEscape(parameterToString(r.clusterId, "")), -1) localVarHeaderParams := make(map[string]string) localVarQueryParams := _neturl.Values{} localVarFormParams := _neturl.Values{} - - if r.name != nil { - localVarQueryParams.Add("name", parameterToString(*r.name, "")) + if strlen(r.clusterId) < 32 { + return localVarReturnValue, nil, reportError("clusterId must have at least 32 elements") + } + if strlen(r.clusterId) > 36 { + return localVarReturnValue, nil, reportError("clusterId must have less than 36 elements") + } + if r.patchClusterRequest == nil { + return localVarReturnValue, nil, reportError("patchClusterRequest is required and must be specified") } + // to determine the Content-Type header - localVarHTTPContentTypes := []string{} + localVarHTTPContentTypes := []string{"application/json"} // set Content-Type header localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes) @@ -784,6 +794,8 @@ func (a *DataPlatformClusterApiService) GetClustersExecute(r ApiGetClustersReque if localVarHTTPHeaderAccept != "" { localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept } + // body params + localVarPostBody = r.patchClusterRequest req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) if err != nil { return localVarReturnValue, nil, err @@ -796,14 +808,14 @@ func (a *DataPlatformClusterApiService) GetClustersExecute(r ApiGetClustersReque Method: localVarHTTPMethod, RequestTime: httpRequestTime, RequestURL: localVarPath, - Operation: "GetClusters", + Operation: "ClustersPatch", } if err != nil || localVarHTTPResponse == nil { return localVarReturnValue, localVarAPIResponse, err } - localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) + localVarBody, err := io.ReadAll(localVarHTTPResponse.Body) localVarHTTPResponse.Body.Close() localVarAPIResponse.Payload = localVarBody if err != nil { @@ -843,6 +855,15 @@ func (a *DataPlatformClusterApiService) GetClustersExecute(r ApiGetClustersReque } newErr.model = v } + if localVarHTTPResponse.StatusCode == 404 { + var v ErrorResponse + err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) + if err != nil { + newErr.error = err.Error() + return localVarReturnValue, localVarAPIResponse, newErr + } + newErr.model = v + } if localVarHTTPResponse.StatusCode == 500 { var v ErrorResponse err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) @@ -868,42 +889,38 @@ func (a *DataPlatformClusterApiService) GetClustersExecute(r ApiGetClustersReque return localVarReturnValue, localVarAPIResponse, nil } -type ApiPatchClusterRequest struct { - ctx _context.Context - ApiService *DataPlatformClusterApiService - clusterId string - patchClusterRequest *PatchClusterRequest +type ApiClustersPostRequest struct { + ctx _context.Context + ApiService *DataPlatformClusterApiService + createClusterRequest *CreateClusterRequest } -func (r ApiPatchClusterRequest) PatchClusterRequest(patchClusterRequest PatchClusterRequest) ApiPatchClusterRequest { - r.patchClusterRequest = &patchClusterRequest +func (r ApiClustersPostRequest) CreateClusterRequest(createClusterRequest CreateClusterRequest) ApiClustersPostRequest { + r.createClusterRequest = &createClusterRequest return r } -func (r ApiPatchClusterRequest) Execute() (ClusterResponseData, *APIResponse, error) { - return r.ApiService.PatchClusterExecute(r) +func (r ApiClustersPostRequest) Execute() (ClusterResponseData, *APIResponse, error) { + return r.ApiService.ClustersPostExecute(r) } /* - - PatchCluster Partially modify a DataPlatformCluster - - Modifies the specified DataPlatformCluster by its distinct cluster ID. + - ClustersPost Create a DataPlatformCluster + - Creates a new DataPlatformCluster. -The fields in the request body are applied to the cluster. -Note that the application to the cluster itself is performed asynchronously. -You can check the sync state by querying the cluster with the GET method. +The cluster will be provisioned in the data center matching the provided `DatacenterId`. +Therefore the data center must be created upfront and must be editable by the user issuing the request. -The ID can be found in the response when a cluster is created -or when you GET a list of all DataPlatformClusters. +To create a new virtual data center (VDC), +[see](https://api.ionos.com/docs/cloud/v6/#tag/Data-centers/operation/datacentersPost). - @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). - - @param clusterId The unique ID of the cluster. Must conform to the UUID format. - - @return ApiPatchClusterRequest + - @return ApiClustersPostRequest */ -func (a *DataPlatformClusterApiService) PatchCluster(ctx _context.Context, clusterId string) ApiPatchClusterRequest { - return ApiPatchClusterRequest{ +func (a *DataPlatformClusterApiService) ClustersPost(ctx _context.Context) ApiClustersPostRequest { + return ApiClustersPostRequest{ ApiService: a, ctx: ctx, - clusterId: clusterId, } } @@ -911,9 +928,9 @@ func (a *DataPlatformClusterApiService) PatchCluster(ctx _context.Context, clust * Execute executes the request * @return ClusterResponseData */ -func (a *DataPlatformClusterApiService) PatchClusterExecute(r ApiPatchClusterRequest) (ClusterResponseData, *APIResponse, error) { +func (a *DataPlatformClusterApiService) ClustersPostExecute(r ApiClustersPostRequest) (ClusterResponseData, *APIResponse, error) { var ( - localVarHTTPMethod = _nethttp.MethodPatch + localVarHTTPMethod = _nethttp.MethodPost localVarPostBody interface{} localVarFormFileName string localVarFileName string @@ -921,25 +938,18 @@ func (a *DataPlatformClusterApiService) PatchClusterExecute(r ApiPatchClusterReq localVarReturnValue ClusterResponseData ) - localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DataPlatformClusterApiService.PatchCluster") + localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DataPlatformClusterApiService.ClustersPost") if err != nil { return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()} } - localVarPath := localBasePath + "/clusters/{clusterId}" - localVarPath = strings.Replace(localVarPath, "{"+"clusterId"+"}", _neturl.PathEscape(parameterToString(r.clusterId, "")), -1) + localVarPath := localBasePath + "/clusters" localVarHeaderParams := make(map[string]string) localVarQueryParams := _neturl.Values{} localVarFormParams := _neturl.Values{} - if strlen(r.clusterId) < 32 { - return localVarReturnValue, nil, reportError("clusterId must have at least 32 elements") - } - if strlen(r.clusterId) > 36 { - return localVarReturnValue, nil, reportError("clusterId must have less than 36 elements") - } - if r.patchClusterRequest == nil { - return localVarReturnValue, nil, reportError("patchClusterRequest is required and must be specified") + if r.createClusterRequest == nil { + return localVarReturnValue, nil, reportError("createClusterRequest is required and must be specified") } // to determine the Content-Type header @@ -960,7 +970,7 @@ func (a *DataPlatformClusterApiService) PatchClusterExecute(r ApiPatchClusterReq localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept } // body params - localVarPostBody = r.patchClusterRequest + localVarPostBody = r.createClusterRequest req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) if err != nil { return localVarReturnValue, nil, err @@ -973,14 +983,14 @@ func (a *DataPlatformClusterApiService) PatchClusterExecute(r ApiPatchClusterReq Method: localVarHTTPMethod, RequestTime: httpRequestTime, RequestURL: localVarPath, - Operation: "PatchCluster", + Operation: "ClustersPost", } if err != nil || localVarHTTPResponse == nil { return localVarReturnValue, localVarAPIResponse, err } - localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) + localVarBody, err := io.ReadAll(localVarHTTPResponse.Body) localVarHTTPResponse.Body.Close() localVarAPIResponse.Payload = localVarBody if err != nil { @@ -1020,15 +1030,6 @@ func (a *DataPlatformClusterApiService) PatchClusterExecute(r ApiPatchClusterReq } newErr.model = v } - if localVarHTTPResponse.StatusCode == 404 { - var v ErrorResponse - err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) - if err != nil { - newErr.error = err.Error() - return localVarReturnValue, localVarAPIResponse, newErr - } - newErr.model = v - } if localVarHTTPResponse.StatusCode == 500 { var v ErrorResponse err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type")) diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/api_data_platform_meta_data.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/api_data_platform_meta_data.go index afe248ad6..f85523164 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/api_data_platform_meta_data.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/api_data_platform_meta_data.go @@ -1,9 +1,9 @@ /* * IONOS Cloud - Managed Stackable Data Platform API * - * Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable Platform. Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the \"Data Center Designer\" (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Datacenter (VDC) The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS-CLI the following way: ``` ionosctl token generate ``` For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) ### Create a new DataPlatformCluster Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use-case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Service To create the desired application, the Stackable service needs to be provided, using the received kubeconfig and [deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic-Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) ### API-Key as Bearer Token The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. (See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. ### Permissions and access roles Currently, an admin can see and manipulate all resources in a contract. A normal authenticated user can only see and manipulate resources he created. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC and can only be modified or deleted via the API. ### References + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References * - * API version: 0.0.7 + * API version: 1.1.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -13,7 +13,7 @@ package ionoscloud import ( _context "context" "fmt" - _ioutil "io/ioutil" + "io" _nethttp "net/http" _neturl "net/url" ) @@ -31,12 +31,12 @@ type ApiVersionsGetRequest struct { ApiService *DataPlatformMetaDataApiService } -func (r ApiVersionsGetRequest) Execute() ([]string, *APIResponse, error) { +func (r ApiVersionsGetRequest) Execute() (VersionsGet200Response, *APIResponse, error) { return r.ApiService.VersionsGetExecute(r) } /* - * VersionsGet Managed Data Stack API version + * VersionsGet Managed Stackable Data Platform API Versions * Retrieves all available versions of the Managed Stackable Data Platform. * @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). * @return ApiVersionsGetRequest @@ -50,16 +50,16 @@ func (a *DataPlatformMetaDataApiService) VersionsGet(ctx _context.Context) ApiVe /* * Execute executes the request - * @return []string + * @return VersionsGet200Response */ -func (a *DataPlatformMetaDataApiService) VersionsGetExecute(r ApiVersionsGetRequest) ([]string, *APIResponse, error) { +func (a *DataPlatformMetaDataApiService) VersionsGetExecute(r ApiVersionsGetRequest) (VersionsGet200Response, *APIResponse, error) { var ( localVarHTTPMethod = _nethttp.MethodGet localVarPostBody interface{} localVarFormFileName string localVarFileName string localVarFileBytes []byte - localVarReturnValue []string + localVarReturnValue VersionsGet200Response ) localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DataPlatformMetaDataApiService.VersionsGet") @@ -109,7 +109,7 @@ func (a *DataPlatformMetaDataApiService) VersionsGetExecute(r ApiVersionsGetRequ return localVarReturnValue, localVarAPIResponse, err } - localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) + localVarBody, err := io.ReadAll(localVarHTTPResponse.Body) localVarHTTPResponse.Body.Close() localVarAPIResponse.Payload = localVarBody if err != nil { diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/api_data_platform_node_pool.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/api_data_platform_node_pool.go index f72f2b23b..d02eb5d76 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/api_data_platform_node_pool.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/api_data_platform_node_pool.go @@ -1,9 +1,9 @@ /* * IONOS Cloud - Managed Stackable Data Platform API * - * Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable Platform. Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the \"Data Center Designer\" (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Datacenter (VDC) The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS-CLI the following way: ``` ionosctl token generate ``` For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) ### Create a new DataPlatformCluster Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use-case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Service To create the desired application, the Stackable service needs to be provided, using the received kubeconfig and [deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic-Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) ### API-Key as Bearer Token The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. (See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. ### Permissions and access roles Currently, an admin can see and manipulate all resources in a contract. A normal authenticated user can only see and manipulate resources he created. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC and can only be modified or deleted via the API. ### References + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References * - * API version: 0.0.7 + * API version: 1.1.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -13,7 +13,7 @@ package ionoscloud import ( _context "context" "fmt" - _ioutil "io/ioutil" + "io" _nethttp "net/http" _neturl "net/url" "strings" @@ -27,38 +27,38 @@ var ( // DataPlatformNodePoolApiService DataPlatformNodePoolApi service type DataPlatformNodePoolApiService service -type ApiCreateClusterNodepoolRequest struct { - ctx _context.Context - ApiService *DataPlatformNodePoolApiService - clusterId string - createNodePoolRequest *CreateNodePoolRequest -} - -func (r ApiCreateClusterNodepoolRequest) CreateNodePoolRequest(createNodePoolRequest CreateNodePoolRequest) ApiCreateClusterNodepoolRequest { - r.createNodePoolRequest = &createNodePoolRequest - return r +type ApiClustersNodepoolsDeleteRequest struct { + ctx _context.Context + ApiService *DataPlatformNodePoolApiService + clusterId string + nodepoolId string } -func (r ApiCreateClusterNodepoolRequest) Execute() (NodePoolResponseData, *APIResponse, error) { - return r.ApiService.CreateClusterNodepoolExecute(r) +func (r ApiClustersNodepoolsDeleteRequest) Execute() (NodePoolResponseData, *APIResponse, error) { + return r.ApiService.ClustersNodepoolsDeleteExecute(r) } /* - - CreateClusterNodepool Create a DataPlatformNodePool for a distinct DataPlatformCluster - - Creates a new node pool and assignes the node pool resources exclusively to the defined managed cluster. + - ClustersNodepoolsDelete Remove a DataPlatformNodePool from a DataPlatformCluster + - Removes the specified node pool from the specified DataPlatformCluster and deletes the node pool afterwards. The cluster ID can be found in the response when a cluster is created or when you GET a list of all DataPlatformClusters. +The node pool ID can be found in the response when a node pool is created +or when you GET a list of all node pools assigned to a specific DataPlatformCluster. + - @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). - @param clusterId The unique ID of the cluster. Must conform to the UUID format. - - @return ApiCreateClusterNodepoolRequest + - @param nodepoolId The unique ID of the node pool. Must conform to the UUID format. + - @return ApiClustersNodepoolsDeleteRequest */ -func (a *DataPlatformNodePoolApiService) CreateClusterNodepool(ctx _context.Context, clusterId string) ApiCreateClusterNodepoolRequest { - return ApiCreateClusterNodepoolRequest{ +func (a *DataPlatformNodePoolApiService) ClustersNodepoolsDelete(ctx _context.Context, clusterId string, nodepoolId string) ApiClustersNodepoolsDeleteRequest { + return ApiClustersNodepoolsDeleteRequest{ ApiService: a, ctx: ctx, clusterId: clusterId, + nodepoolId: nodepoolId, } } @@ -66,9 +66,9 @@ func (a *DataPlatformNodePoolApiService) CreateClusterNodepool(ctx _context.Cont * Execute executes the request * @return NodePoolResponseData */ -func (a *DataPlatformNodePoolApiService) CreateClusterNodepoolExecute(r ApiCreateClusterNodepoolRequest) (NodePoolResponseData, *APIResponse, error) { +func (a *DataPlatformNodePoolApiService) ClustersNodepoolsDeleteExecute(r ApiClustersNodepoolsDeleteRequest) (NodePoolResponseData, *APIResponse, error) { var ( - localVarHTTPMethod = _nethttp.MethodPost + localVarHTTPMethod = _nethttp.MethodDelete localVarPostBody interface{} localVarFormFileName string localVarFileName string @@ -76,13 +76,14 @@ func (a *DataPlatformNodePoolApiService) CreateClusterNodepoolExecute(r ApiCreat localVarReturnValue NodePoolResponseData ) - localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DataPlatformNodePoolApiService.CreateClusterNodepool") + localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DataPlatformNodePoolApiService.ClustersNodepoolsDelete") if err != nil { return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()} } - localVarPath := localBasePath + "/clusters/{clusterId}/nodepools" + localVarPath := localBasePath + "/clusters/{clusterId}/nodepools/{nodepoolId}" localVarPath = strings.Replace(localVarPath, "{"+"clusterId"+"}", _neturl.PathEscape(parameterToString(r.clusterId, "")), -1) + localVarPath = strings.Replace(localVarPath, "{"+"nodepoolId"+"}", _neturl.PathEscape(parameterToString(r.nodepoolId, "")), -1) localVarHeaderParams := make(map[string]string) localVarQueryParams := _neturl.Values{} @@ -93,12 +94,15 @@ func (a *DataPlatformNodePoolApiService) CreateClusterNodepoolExecute(r ApiCreat if strlen(r.clusterId) > 36 { return localVarReturnValue, nil, reportError("clusterId must have less than 36 elements") } - if r.createNodePoolRequest == nil { - return localVarReturnValue, nil, reportError("createNodePoolRequest is required and must be specified") + if strlen(r.nodepoolId) < 32 { + return localVarReturnValue, nil, reportError("nodepoolId must have at least 32 elements") + } + if strlen(r.nodepoolId) > 36 { + return localVarReturnValue, nil, reportError("nodepoolId must have less than 36 elements") } // to determine the Content-Type header - localVarHTTPContentTypes := []string{"application/json"} + localVarHTTPContentTypes := []string{} // set Content-Type header localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes) @@ -114,8 +118,6 @@ func (a *DataPlatformNodePoolApiService) CreateClusterNodepoolExecute(r ApiCreat if localVarHTTPHeaderAccept != "" { localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept } - // body params - localVarPostBody = r.createNodePoolRequest req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) if err != nil { return localVarReturnValue, nil, err @@ -128,14 +130,14 @@ func (a *DataPlatformNodePoolApiService) CreateClusterNodepoolExecute(r ApiCreat Method: localVarHTTPMethod, RequestTime: httpRequestTime, RequestURL: localVarPath, - Operation: "CreateClusterNodepool", + Operation: "ClustersNodepoolsDelete", } if err != nil || localVarHTTPResponse == nil { return localVarReturnValue, localVarAPIResponse, err } - localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) + localVarBody, err := io.ReadAll(localVarHTTPResponse.Body) localVarHTTPResponse.Body.Close() localVarAPIResponse.Payload = localVarBody if err != nil { @@ -209,20 +211,20 @@ func (a *DataPlatformNodePoolApiService) CreateClusterNodepoolExecute(r ApiCreat return localVarReturnValue, localVarAPIResponse, nil } -type ApiDeleteClusterNodepoolRequest struct { +type ApiClustersNodepoolsFindByIdRequest struct { ctx _context.Context ApiService *DataPlatformNodePoolApiService clusterId string nodepoolId string } -func (r ApiDeleteClusterNodepoolRequest) Execute() (NodePoolResponseData, *APIResponse, error) { - return r.ApiService.DeleteClusterNodepoolExecute(r) +func (r ApiClustersNodepoolsFindByIdRequest) Execute() (NodePoolResponseData, *APIResponse, error) { + return r.ApiService.ClustersNodepoolsFindByIdExecute(r) } /* - - DeleteClusterNodepool Remove node pool from DataPlatformCluster. - - Removes the specified node pool from the specified DataPlatformCluster and deletes the node pool afterwards. + - ClustersNodepoolsFindById Retrieve a DataPlatformNodePool + - Retrieve a node pool belonging to a Kubernetes cluster running Stackable by using its ID. The cluster ID can be found in the response when a cluster is created or when you GET a list of all DataPlatformClusters. @@ -233,10 +235,10 @@ or when you GET a list of all node pools assigned to a specific DataPlatformClus - @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). - @param clusterId The unique ID of the cluster. Must conform to the UUID format. - @param nodepoolId The unique ID of the node pool. Must conform to the UUID format. - - @return ApiDeleteClusterNodepoolRequest + - @return ApiClustersNodepoolsFindByIdRequest */ -func (a *DataPlatformNodePoolApiService) DeleteClusterNodepool(ctx _context.Context, clusterId string, nodepoolId string) ApiDeleteClusterNodepoolRequest { - return ApiDeleteClusterNodepoolRequest{ +func (a *DataPlatformNodePoolApiService) ClustersNodepoolsFindById(ctx _context.Context, clusterId string, nodepoolId string) ApiClustersNodepoolsFindByIdRequest { + return ApiClustersNodepoolsFindByIdRequest{ ApiService: a, ctx: ctx, clusterId: clusterId, @@ -248,9 +250,9 @@ func (a *DataPlatformNodePoolApiService) DeleteClusterNodepool(ctx _context.Cont * Execute executes the request * @return NodePoolResponseData */ -func (a *DataPlatformNodePoolApiService) DeleteClusterNodepoolExecute(r ApiDeleteClusterNodepoolRequest) (NodePoolResponseData, *APIResponse, error) { +func (a *DataPlatformNodePoolApiService) ClustersNodepoolsFindByIdExecute(r ApiClustersNodepoolsFindByIdRequest) (NodePoolResponseData, *APIResponse, error) { var ( - localVarHTTPMethod = _nethttp.MethodDelete + localVarHTTPMethod = _nethttp.MethodGet localVarPostBody interface{} localVarFormFileName string localVarFileName string @@ -258,7 +260,7 @@ func (a *DataPlatformNodePoolApiService) DeleteClusterNodepoolExecute(r ApiDelet localVarReturnValue NodePoolResponseData ) - localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DataPlatformNodePoolApiService.DeleteClusterNodepool") + localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DataPlatformNodePoolApiService.ClustersNodepoolsFindById") if err != nil { return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()} } @@ -312,14 +314,14 @@ func (a *DataPlatformNodePoolApiService) DeleteClusterNodepoolExecute(r ApiDelet Method: localVarHTTPMethod, RequestTime: httpRequestTime, RequestURL: localVarPath, - Operation: "DeleteClusterNodepool", + Operation: "ClustersNodepoolsFindById", } if err != nil || localVarHTTPResponse == nil { return localVarReturnValue, localVarAPIResponse, err } - localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) + localVarBody, err := io.ReadAll(localVarHTTPResponse.Body) localVarHTTPResponse.Body.Close() localVarAPIResponse.Payload = localVarBody if err != nil { @@ -393,63 +395,56 @@ func (a *DataPlatformNodePoolApiService) DeleteClusterNodepoolExecute(r ApiDelet return localVarReturnValue, localVarAPIResponse, nil } -type ApiGetClusterNodepoolRequest struct { +type ApiClustersNodepoolsGetRequest struct { ctx _context.Context ApiService *DataPlatformNodePoolApiService clusterId string - nodepoolId string } -func (r ApiGetClusterNodepoolRequest) Execute() (NodePoolResponseData, *APIResponse, error) { - return r.ApiService.GetClusterNodepoolExecute(r) +func (r ApiClustersNodepoolsGetRequest) Execute() (NodePoolListResponseData, *APIResponse, error) { + return r.ApiService.ClustersNodepoolsGetExecute(r) } /* - - GetClusterNodepool Retrieve a DataPlatformNodePool - - Retrieve a node pool belonging to a Kubernetes cluster running Stackable by using its ID. + - ClustersNodepoolsGet List the DataPlatformNodePools of a DataPlatformCluster + - List all node pools assigned to the specified DataPlatformCluster by its ID. The cluster ID can be found in the response when a cluster is created or when you GET a list of all DataPlatformClusters. -The node pool ID can be found in the response when a node pool is created -or when you GET a list of all node pools assigned to a specific DataPlatformCluster. - - @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). - @param clusterId The unique ID of the cluster. Must conform to the UUID format. - - @param nodepoolId The unique ID of the node pool. Must conform to the UUID format. - - @return ApiGetClusterNodepoolRequest + - @return ApiClustersNodepoolsGetRequest */ -func (a *DataPlatformNodePoolApiService) GetClusterNodepool(ctx _context.Context, clusterId string, nodepoolId string) ApiGetClusterNodepoolRequest { - return ApiGetClusterNodepoolRequest{ +func (a *DataPlatformNodePoolApiService) ClustersNodepoolsGet(ctx _context.Context, clusterId string) ApiClustersNodepoolsGetRequest { + return ApiClustersNodepoolsGetRequest{ ApiService: a, ctx: ctx, clusterId: clusterId, - nodepoolId: nodepoolId, } } /* * Execute executes the request - * @return NodePoolResponseData + * @return NodePoolListResponseData */ -func (a *DataPlatformNodePoolApiService) GetClusterNodepoolExecute(r ApiGetClusterNodepoolRequest) (NodePoolResponseData, *APIResponse, error) { +func (a *DataPlatformNodePoolApiService) ClustersNodepoolsGetExecute(r ApiClustersNodepoolsGetRequest) (NodePoolListResponseData, *APIResponse, error) { var ( localVarHTTPMethod = _nethttp.MethodGet localVarPostBody interface{} localVarFormFileName string localVarFileName string localVarFileBytes []byte - localVarReturnValue NodePoolResponseData + localVarReturnValue NodePoolListResponseData ) - localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DataPlatformNodePoolApiService.GetClusterNodepool") + localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DataPlatformNodePoolApiService.ClustersNodepoolsGet") if err != nil { return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()} } - localVarPath := localBasePath + "/clusters/{clusterId}/nodepools/{nodepoolId}" + localVarPath := localBasePath + "/clusters/{clusterId}/nodepools" localVarPath = strings.Replace(localVarPath, "{"+"clusterId"+"}", _neturl.PathEscape(parameterToString(r.clusterId, "")), -1) - localVarPath = strings.Replace(localVarPath, "{"+"nodepoolId"+"}", _neturl.PathEscape(parameterToString(r.nodepoolId, "")), -1) localVarHeaderParams := make(map[string]string) localVarQueryParams := _neturl.Values{} @@ -460,12 +455,6 @@ func (a *DataPlatformNodePoolApiService) GetClusterNodepoolExecute(r ApiGetClust if strlen(r.clusterId) > 36 { return localVarReturnValue, nil, reportError("clusterId must have less than 36 elements") } - if strlen(r.nodepoolId) < 32 { - return localVarReturnValue, nil, reportError("nodepoolId must have at least 32 elements") - } - if strlen(r.nodepoolId) > 36 { - return localVarReturnValue, nil, reportError("nodepoolId must have less than 36 elements") - } // to determine the Content-Type header localVarHTTPContentTypes := []string{} @@ -496,14 +485,14 @@ func (a *DataPlatformNodePoolApiService) GetClusterNodepoolExecute(r ApiGetClust Method: localVarHTTPMethod, RequestTime: httpRequestTime, RequestURL: localVarPath, - Operation: "GetClusterNodepool", + Operation: "ClustersNodepoolsGet", } if err != nil || localVarHTTPResponse == nil { return localVarReturnValue, localVarAPIResponse, err } - localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) + localVarBody, err := io.ReadAll(localVarHTTPResponse.Body) localVarHTTPResponse.Body.Close() localVarAPIResponse.Payload = localVarBody if err != nil { @@ -577,56 +566,75 @@ func (a *DataPlatformNodePoolApiService) GetClusterNodepoolExecute(r ApiGetClust return localVarReturnValue, localVarAPIResponse, nil } -type ApiGetClusterNodepoolsRequest struct { - ctx _context.Context - ApiService *DataPlatformNodePoolApiService - clusterId string +type ApiClustersNodepoolsPatchRequest struct { + ctx _context.Context + ApiService *DataPlatformNodePoolApiService + clusterId string + nodepoolId string + patchNodePoolRequest *PatchNodePoolRequest +} + +func (r ApiClustersNodepoolsPatchRequest) PatchNodePoolRequest(patchNodePoolRequest PatchNodePoolRequest) ApiClustersNodepoolsPatchRequest { + r.patchNodePoolRequest = &patchNodePoolRequest + return r } -func (r ApiGetClusterNodepoolsRequest) Execute() (NodePoolListResponseData, *APIResponse, error) { - return r.ApiService.GetClusterNodepoolsExecute(r) +func (r ApiClustersNodepoolsPatchRequest) Execute() (NodePoolResponseData, *APIResponse, error) { + return r.ApiService.ClustersNodepoolsPatchExecute(r) } /* - - GetClusterNodepools List the DataPlatformNodePools of a DataPlatformCluster - - List all node pools assigned to the specified DataplatformCluster by its ID. + - ClustersNodepoolsPatch Partially Modify a DataPlatformNodePool + - Modifies the specified node pool of a DataPlatformCluster. + +Update selected attributes of a node pool belonging to a Kubernetes cluster running Stackable. + +The fields in the request body are applied to the cluster. +Note that the application to the node pool itself is performed asynchronously. +You can check the sync state by querying the node pool with the GET method. The cluster ID can be found in the response when a cluster is created or when you GET a list of all DataPlatformClusters. +The node pool ID can be found in the response when a node pool is created +or when you GET a list of all node pools assigned to a specific DataPlatformCluster. + - @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). - @param clusterId The unique ID of the cluster. Must conform to the UUID format. - - @return ApiGetClusterNodepoolsRequest + - @param nodepoolId The unique ID of the node pool. Must conform to the UUID format. + - @return ApiClustersNodepoolsPatchRequest */ -func (a *DataPlatformNodePoolApiService) GetClusterNodepools(ctx _context.Context, clusterId string) ApiGetClusterNodepoolsRequest { - return ApiGetClusterNodepoolsRequest{ +func (a *DataPlatformNodePoolApiService) ClustersNodepoolsPatch(ctx _context.Context, clusterId string, nodepoolId string) ApiClustersNodepoolsPatchRequest { + return ApiClustersNodepoolsPatchRequest{ ApiService: a, ctx: ctx, clusterId: clusterId, + nodepoolId: nodepoolId, } } /* * Execute executes the request - * @return NodePoolListResponseData + * @return NodePoolResponseData */ -func (a *DataPlatformNodePoolApiService) GetClusterNodepoolsExecute(r ApiGetClusterNodepoolsRequest) (NodePoolListResponseData, *APIResponse, error) { +func (a *DataPlatformNodePoolApiService) ClustersNodepoolsPatchExecute(r ApiClustersNodepoolsPatchRequest) (NodePoolResponseData, *APIResponse, error) { var ( - localVarHTTPMethod = _nethttp.MethodGet + localVarHTTPMethod = _nethttp.MethodPatch localVarPostBody interface{} localVarFormFileName string localVarFileName string localVarFileBytes []byte - localVarReturnValue NodePoolListResponseData + localVarReturnValue NodePoolResponseData ) - localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DataPlatformNodePoolApiService.GetClusterNodepools") + localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DataPlatformNodePoolApiService.ClustersNodepoolsPatch") if err != nil { return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()} } - localVarPath := localBasePath + "/clusters/{clusterId}/nodepools" + localVarPath := localBasePath + "/clusters/{clusterId}/nodepools/{nodepoolId}" localVarPath = strings.Replace(localVarPath, "{"+"clusterId"+"}", _neturl.PathEscape(parameterToString(r.clusterId, "")), -1) + localVarPath = strings.Replace(localVarPath, "{"+"nodepoolId"+"}", _neturl.PathEscape(parameterToString(r.nodepoolId, "")), -1) localVarHeaderParams := make(map[string]string) localVarQueryParams := _neturl.Values{} @@ -637,9 +645,18 @@ func (a *DataPlatformNodePoolApiService) GetClusterNodepoolsExecute(r ApiGetClus if strlen(r.clusterId) > 36 { return localVarReturnValue, nil, reportError("clusterId must have less than 36 elements") } + if strlen(r.nodepoolId) < 32 { + return localVarReturnValue, nil, reportError("nodepoolId must have at least 32 elements") + } + if strlen(r.nodepoolId) > 36 { + return localVarReturnValue, nil, reportError("nodepoolId must have less than 36 elements") + } + if r.patchNodePoolRequest == nil { + return localVarReturnValue, nil, reportError("patchNodePoolRequest is required and must be specified") + } // to determine the Content-Type header - localVarHTTPContentTypes := []string{} + localVarHTTPContentTypes := []string{"application/json"} // set Content-Type header localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes) @@ -655,6 +672,8 @@ func (a *DataPlatformNodePoolApiService) GetClusterNodepoolsExecute(r ApiGetClus if localVarHTTPHeaderAccept != "" { localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept } + // body params + localVarPostBody = r.patchNodePoolRequest req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) if err != nil { return localVarReturnValue, nil, err @@ -667,14 +686,14 @@ func (a *DataPlatformNodePoolApiService) GetClusterNodepoolsExecute(r ApiGetClus Method: localVarHTTPMethod, RequestTime: httpRequestTime, RequestURL: localVarPath, - Operation: "GetClusterNodepools", + Operation: "ClustersNodepoolsPatch", } if err != nil || localVarHTTPResponse == nil { return localVarReturnValue, localVarAPIResponse, err } - localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) + localVarBody, err := io.ReadAll(localVarHTTPResponse.Body) localVarHTTPResponse.Body.Close() localVarAPIResponse.Payload = localVarBody if err != nil { @@ -748,50 +767,38 @@ func (a *DataPlatformNodePoolApiService) GetClusterNodepoolsExecute(r ApiGetClus return localVarReturnValue, localVarAPIResponse, nil } -type ApiPatchClusterNodepoolRequest struct { - ctx _context.Context - ApiService *DataPlatformNodePoolApiService - clusterId string - nodepoolId string - patchNodePoolRequest *PatchNodePoolRequest +type ApiClustersNodepoolsPostRequest struct { + ctx _context.Context + ApiService *DataPlatformNodePoolApiService + clusterId string + createNodePoolRequest *CreateNodePoolRequest } -func (r ApiPatchClusterNodepoolRequest) PatchNodePoolRequest(patchNodePoolRequest PatchNodePoolRequest) ApiPatchClusterNodepoolRequest { - r.patchNodePoolRequest = &patchNodePoolRequest +func (r ApiClustersNodepoolsPostRequest) CreateNodePoolRequest(createNodePoolRequest CreateNodePoolRequest) ApiClustersNodepoolsPostRequest { + r.createNodePoolRequest = &createNodePoolRequest return r } -func (r ApiPatchClusterNodepoolRequest) Execute() (NodePoolResponseData, *APIResponse, error) { - return r.ApiService.PatchClusterNodepoolExecute(r) +func (r ApiClustersNodepoolsPostRequest) Execute() (NodePoolResponseData, *APIResponse, error) { + return r.ApiService.ClustersNodepoolsPostExecute(r) } /* - - PatchClusterNodepool Partially modify a DataPlatformNodePool - - Modifies the specified node pool of a DataPlatformCluster. - -Update selected attributes of a node pool belonging to a Kubernetes cluster running Stackable. - -The fields in the request body are applied to the cluster. -Note that the application to the node pool itself is performed asynchronously. -You can check the sync state by querying the node pool with the GET method. + - ClustersNodepoolsPost Create a DataPlatformNodePool for a distinct DataPlatformCluster + - Creates a new node pool and assigns the node pool resources exclusively to the defined managed cluster. The cluster ID can be found in the response when a cluster is created or when you GET a list of all DataPlatformClusters. -The node pool ID can be found in the response when a node pool is created -or when you GET a list of all node pools assigned to a specific DataPlatformCluster. - - @param ctx _context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background(). - @param clusterId The unique ID of the cluster. Must conform to the UUID format. - - @param nodepoolId The unique ID of the node pool. Must conform to the UUID format. - - @return ApiPatchClusterNodepoolRequest + - @return ApiClustersNodepoolsPostRequest */ -func (a *DataPlatformNodePoolApiService) PatchClusterNodepool(ctx _context.Context, clusterId string, nodepoolId string) ApiPatchClusterNodepoolRequest { - return ApiPatchClusterNodepoolRequest{ +func (a *DataPlatformNodePoolApiService) ClustersNodepoolsPost(ctx _context.Context, clusterId string) ApiClustersNodepoolsPostRequest { + return ApiClustersNodepoolsPostRequest{ ApiService: a, ctx: ctx, clusterId: clusterId, - nodepoolId: nodepoolId, } } @@ -799,9 +806,9 @@ func (a *DataPlatformNodePoolApiService) PatchClusterNodepool(ctx _context.Conte * Execute executes the request * @return NodePoolResponseData */ -func (a *DataPlatformNodePoolApiService) PatchClusterNodepoolExecute(r ApiPatchClusterNodepoolRequest) (NodePoolResponseData, *APIResponse, error) { +func (a *DataPlatformNodePoolApiService) ClustersNodepoolsPostExecute(r ApiClustersNodepoolsPostRequest) (NodePoolResponseData, *APIResponse, error) { var ( - localVarHTTPMethod = _nethttp.MethodPatch + localVarHTTPMethod = _nethttp.MethodPost localVarPostBody interface{} localVarFormFileName string localVarFileName string @@ -809,14 +816,13 @@ func (a *DataPlatformNodePoolApiService) PatchClusterNodepoolExecute(r ApiPatchC localVarReturnValue NodePoolResponseData ) - localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DataPlatformNodePoolApiService.PatchClusterNodepool") + localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "DataPlatformNodePoolApiService.ClustersNodepoolsPost") if err != nil { return localVarReturnValue, nil, GenericOpenAPIError{error: err.Error()} } - localVarPath := localBasePath + "/clusters/{clusterId}/nodepools/{nodepoolId}" + localVarPath := localBasePath + "/clusters/{clusterId}/nodepools" localVarPath = strings.Replace(localVarPath, "{"+"clusterId"+"}", _neturl.PathEscape(parameterToString(r.clusterId, "")), -1) - localVarPath = strings.Replace(localVarPath, "{"+"nodepoolId"+"}", _neturl.PathEscape(parameterToString(r.nodepoolId, "")), -1) localVarHeaderParams := make(map[string]string) localVarQueryParams := _neturl.Values{} @@ -827,14 +833,8 @@ func (a *DataPlatformNodePoolApiService) PatchClusterNodepoolExecute(r ApiPatchC if strlen(r.clusterId) > 36 { return localVarReturnValue, nil, reportError("clusterId must have less than 36 elements") } - if strlen(r.nodepoolId) < 32 { - return localVarReturnValue, nil, reportError("nodepoolId must have at least 32 elements") - } - if strlen(r.nodepoolId) > 36 { - return localVarReturnValue, nil, reportError("nodepoolId must have less than 36 elements") - } - if r.patchNodePoolRequest == nil { - return localVarReturnValue, nil, reportError("patchNodePoolRequest is required and must be specified") + if r.createNodePoolRequest == nil { + return localVarReturnValue, nil, reportError("createNodePoolRequest is required and must be specified") } // to determine the Content-Type header @@ -855,7 +855,7 @@ func (a *DataPlatformNodePoolApiService) PatchClusterNodepoolExecute(r ApiPatchC localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept } // body params - localVarPostBody = r.patchNodePoolRequest + localVarPostBody = r.createNodePoolRequest req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes) if err != nil { return localVarReturnValue, nil, err @@ -868,14 +868,14 @@ func (a *DataPlatformNodePoolApiService) PatchClusterNodepoolExecute(r ApiPatchC Method: localVarHTTPMethod, RequestTime: httpRequestTime, RequestURL: localVarPath, - Operation: "PatchClusterNodepool", + Operation: "ClustersNodepoolsPost", } if err != nil || localVarHTTPResponse == nil { return localVarReturnValue, localVarAPIResponse, err } - localVarBody, err := _ioutil.ReadAll(localVarHTTPResponse.Body) + localVarBody, err := io.ReadAll(localVarHTTPResponse.Body) localVarHTTPResponse.Body.Close() localVarAPIResponse.Payload = localVarBody if err != nil { diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/client.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/client.go index 73f7cad6b..66e8966cd 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/client.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/client.go @@ -1,9 +1,9 @@ /* * IONOS Cloud - Managed Stackable Data Platform API * - * Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable Platform. Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the \"Data Center Designer\" (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Datacenter (VDC) The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS-CLI the following way: ``` ionosctl token generate ``` For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) ### Create a new DataPlatformCluster Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use-case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Service To create the desired application, the Stackable service needs to be provided, using the received kubeconfig and [deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic-Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) ### API-Key as Bearer Token The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. (See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. ### Permissions and access roles Currently, an admin can see and manipulate all resources in a contract. A normal authenticated user can only see and manipulate resources he created. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC and can only be modified or deleted via the API. ### References + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References * - * API version: 0.0.7 + * API version: 1.1.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -50,10 +50,10 @@ const ( RequestStatusFailed = "FAILED" RequestStatusDone = "DONE" - Version = "1.0.0" + Version = "1.0.3" ) -// APIClient manages communication with the IONOS Cloud - Managed Stackable Data Platform API API v0.0.7 +// APIClient manages communication with the IONOS Cloud - Managed Stackable Data Platform API API v1.1.0 // In most cases there should be only one, shared, APIClient. type APIClient struct { cfg *Configuration @@ -294,6 +294,9 @@ func (c *APIClient) callAPI(request *http.Request) (*http.Response, time.Duratio case http.StatusServiceUnavailable, http.StatusGatewayTimeout, http.StatusBadGateway: + if request.Method == http.MethodPost { + return resp, httpRequestTime, err + } backoffTime = c.GetConfig().WaitTime case http.StatusTooManyRequests: @@ -317,21 +320,31 @@ func (c *APIClient) callAPI(request *http.Request) (*http.Response, time.Duratio } break } else { - c.backOff(backoffTime) + c.backOff(request.Context(), backoffTime) } } return resp, httpRequestTime, err } -func (c *APIClient) backOff(t time.Duration) { +func (c *APIClient) backOff(ctx context.Context, t time.Duration) { if t > c.GetConfig().MaxWaitTime { t = c.GetConfig().MaxWaitTime } if c.cfg.Debug || c.cfg.LogLevel.Satisfies(Debug) { c.cfg.Logger.Printf(" Sleeping %s before retrying request\n", t.String()) } - time.Sleep(t) + if t <= 0 { + return + } + + timer := time.NewTimer(t) + defer timer.Stop() + + select { + case <-ctx.Done(): + case <-timer.C: + } } // Allow modification of underlying config for alternate implementations and testing diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/configuration.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/configuration.go index bb056f7f0..da25cdc41 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/configuration.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/configuration.go @@ -1,9 +1,9 @@ /* * IONOS Cloud - Managed Stackable Data Platform API * - * Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable Platform. Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the \"Data Center Designer\" (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Datacenter (VDC) The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS-CLI the following way: ``` ionosctl token generate ``` For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) ### Create a new DataPlatformCluster Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use-case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Service To create the desired application, the Stackable service needs to be provided, using the received kubeconfig and [deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic-Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) ### API-Key as Bearer Token The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. (See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. ### Permissions and access roles Currently, an admin can see and manipulate all resources in a contract. A normal authenticated user can only see and manipulate resources he created. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC and can only be modified or deleted via the API. ### References + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References * - * API version: 0.0.7 + * API version: 1.1.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -128,7 +128,7 @@ func NewConfiguration(username, password, token, hostUrl string) *Configuration cfg := &Configuration{ DefaultHeader: make(map[string]string), DefaultQueryParams: url.Values{}, - UserAgent: "ionos-cloud-sdk-go-dataplatform/v1.0.0", + UserAgent: "ionos-cloud-sdk-go-dataplatform/v1.0.3", Debug: false, Username: username, Password: password, @@ -141,7 +141,7 @@ func NewConfiguration(username, password, token, hostUrl string) *Configuration Servers: ServerConfigurations{ { URL: getServerUrl(hostUrl), - Description: "IONOS Cloud Dataplatform API", + Description: "IONOS Cloud - Managed Stackable Data Platform API", }, }, OperationServers: map[string]ServerConfigurations{}, diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/logger.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/logger.go index 6a409ca4c..b914a90fd 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/logger.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/logger.go @@ -1,9 +1,9 @@ /* * IONOS Cloud - Managed Stackable Data Platform API * - * Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable Platform. Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the \"Data Center Designer\" (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Datacenter (VDC) The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS-CLI the following way: ``` ionosctl token generate ``` For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) ### Create a new DataPlatformCluster Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use-case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Service To create the desired application, the Stackable service needs to be provided, using the received kubeconfig and [deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic-Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) ### API-Key as Bearer Token The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. (See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. ### Permissions and access roles Currently, an admin can see and manipulate all resources in a contract. A normal authenticated user can only see and manipulate resources he created. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC and can only be modified or deleted via the API. ### References + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References * - * API version: 0.0.7 + * API version: 1.1.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_availability_zone.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_availability_zone.go index adf282ac0..46a8179cc 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_availability_zone.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_availability_zone.go @@ -1,9 +1,9 @@ /* * IONOS Cloud - Managed Stackable Data Platform API * - * Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable Platform. Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the \"Data Center Designer\" (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Datacenter (VDC) The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS-CLI the following way: ``` ionosctl token generate ``` For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) ### Create a new DataPlatformCluster Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use-case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Service To create the desired application, the Stackable service needs to be provided, using the received kubeconfig and [deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic-Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) ### API-Key as Bearer Token The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. (See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. ### Permissions and access roles Currently, an admin can see and manipulate all resources in a contract. A normal authenticated user can only see and manipulate resources he created. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC and can only be modified or deleted via the API. ### References + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References * - * API version: 0.0.7 + * API version: 1.1.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -15,14 +15,14 @@ import ( "fmt" ) -// AvailabilityZone The availability zone of the virtual datacenter region where the node pool resources should be provisioned. +// AvailabilityZone The availability zone of the virtual data center region where the node pool resources should be provisioned. type AvailabilityZone string // List of AvailabilityZone const ( - AUTO AvailabilityZone = "AUTO" - ZONE_1 AvailabilityZone = "ZONE_1" - ZONE_2 AvailabilityZone = "ZONE_2" + AVAILABILITYZONE_AUTO AvailabilityZone = "AUTO" + AVAILABILITYZONE_ZONE_1 AvailabilityZone = "ZONE_1" + AVAILABILITYZONE_ZONE_2 AvailabilityZone = "ZONE_2" ) func (v *AvailabilityZone) UnmarshalJSON(src []byte) error { diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_cluster.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_cluster.go index b35d7fbb4..d7a3f658e 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_cluster.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_cluster.go @@ -1,9 +1,9 @@ /* * IONOS Cloud - Managed Stackable Data Platform API * - * Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable Platform. Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the \"Data Center Designer\" (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Datacenter (VDC) The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS-CLI the following way: ``` ionosctl token generate ``` For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) ### Create a new DataPlatformCluster Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use-case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Service To create the desired application, the Stackable service needs to be provided, using the received kubeconfig and [deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic-Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) ### API-Key as Bearer Token The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. (See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. ### Permissions and access roles Currently, an admin can see and manipulate all resources in a contract. A normal authenticated user can only see and manipulate resources he created. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC and can only be modified or deleted via the API. ### References + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References * - * API version: 0.0.7 + * API version: 1.1.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -14,15 +14,17 @@ import ( "encoding/json" ) -// Cluster A DataPlatformCluster +// Cluster A DataPlatformCluster. type Cluster struct { - // The name of your cluster. Must be 63 characters or less and must begin and end with an alphanumeric character ([a-z0-9A-Z]) with dashes (-), underscores (_), dots (.), and alphanumerics between. + // The name of your cluster. Must be 63 characters or less and must begin and end with an alphanumeric character (`[a-z0-9A-Z]`) with dashes (`-`), underscores (`_`), dots (`.`), and alphanumerics between. Name *string `json:"name,omitempty"` - // The version of the DataPlatform. + // The version of the data platform. DataPlatformVersion *string `json:"dataPlatformVersion,omitempty"` // The UUID of the virtual data center (VDC) the cluster is provisioned. DatacenterId *string `json:"datacenterId,omitempty"` MaintenanceWindow *MaintenanceWindow `json:"maintenanceWindow,omitempty"` + // A list of LANs you want this node pool to be part of. + Lans *[]Lan `json:"lans,omitempty"` } // NewCluster instantiates a new Cluster object @@ -195,6 +197,44 @@ func (o *Cluster) HasMaintenanceWindow() bool { return false } +// GetLans returns the Lans field value +// If the value is explicit nil, the zero value for []Lan will be returned +func (o *Cluster) GetLans() *[]Lan { + if o == nil { + return nil + } + + return o.Lans + +} + +// GetLansOk returns a tuple with the Lans field value +// and a boolean to check if the value has been set. +// NOTE: If the value is an explicit nil, `nil, true` will be returned +func (o *Cluster) GetLansOk() (*[]Lan, bool) { + if o == nil { + return nil, false + } + + return o.Lans, true +} + +// SetLans sets field value +func (o *Cluster) SetLans(v []Lan) { + + o.Lans = &v + +} + +// HasLans returns a boolean if a field has been set. +func (o *Cluster) HasLans() bool { + if o != nil && o.Lans != nil { + return true + } + + return false +} + func (o Cluster) MarshalJSON() ([]byte, error) { toSerialize := map[string]interface{}{} if o.Name != nil { @@ -213,6 +253,10 @@ func (o Cluster) MarshalJSON() ([]byte, error) { toSerialize["maintenanceWindow"] = o.MaintenanceWindow } + if o.Lans != nil { + toSerialize["lans"] = o.Lans + } + return json.Marshal(toSerialize) } diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_cluster_list_response_data.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_cluster_list_response_data.go index 440647d2a..a74e01611 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_cluster_list_response_data.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_cluster_list_response_data.go @@ -1,9 +1,9 @@ /* * IONOS Cloud - Managed Stackable Data Platform API * - * Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable Platform. Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the \"Data Center Designer\" (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Datacenter (VDC) The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS-CLI the following way: ``` ionosctl token generate ``` For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) ### Create a new DataPlatformCluster Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use-case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Service To create the desired application, the Stackable service needs to be provided, using the received kubeconfig and [deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic-Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) ### API-Key as Bearer Token The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. (See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. ### Permissions and access roles Currently, an admin can see and manipulate all resources in a contract. A normal authenticated user can only see and manipulate resources he created. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC and can only be modified or deleted via the API. ### References + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References * - * API version: 0.0.7 + * API version: 1.1.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -14,7 +14,7 @@ import ( "encoding/json" ) -// ClusterListResponseData Data of a cluster list +// ClusterListResponseData Data of a cluster list. type ClusterListResponseData struct { // The ID of a list of resources. Id *string `json:"id,omitempty"` diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_cluster_response_data.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_cluster_response_data.go index 104190aa9..887b04728 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_cluster_response_data.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_cluster_response_data.go @@ -1,9 +1,9 @@ /* * IONOS Cloud - Managed Stackable Data Platform API * - * Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable Platform. Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the \"Data Center Designer\" (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Datacenter (VDC) The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS-CLI the following way: ``` ionosctl token generate ``` For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) ### Create a new DataPlatformCluster Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use-case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Service To create the desired application, the Stackable service needs to be provided, using the received kubeconfig and [deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic-Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) ### API-Key as Bearer Token The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. (See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. ### Permissions and access roles Currently, an admin can see and manipulate all resources in a contract. A normal authenticated user can only see and manipulate resources he created. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC and can only be modified or deleted via the API. ### References + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References * - * API version: 0.0.7 + * API version: 1.1.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -14,7 +14,7 @@ import ( "encoding/json" ) -// ClusterResponseData Data of a cluster +// ClusterResponseData Data of a cluster. type ClusterResponseData struct { // The unique ID of the resource. Must conform to the UUID format. Id *string `json:"id"` diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_create_cluster_properties.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_create_cluster_properties.go index 77ba57dff..2cc6a5d2d 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_create_cluster_properties.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_create_cluster_properties.go @@ -1,9 +1,9 @@ /* * IONOS Cloud - Managed Stackable Data Platform API * - * Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable Platform. Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the \"Data Center Designer\" (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Datacenter (VDC) The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS-CLI the following way: ``` ionosctl token generate ``` For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) ### Create a new DataPlatformCluster Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use-case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Service To create the desired application, the Stackable service needs to be provided, using the received kubeconfig and [deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic-Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) ### API-Key as Bearer Token The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. (See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. ### Permissions and access roles Currently, an admin can see and manipulate all resources in a contract. A normal authenticated user can only see and manipulate resources he created. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC and can only be modified or deleted via the API. ### References + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References * - * API version: 0.0.7 + * API version: 1.1.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -16,13 +16,15 @@ import ( // CreateClusterProperties struct for CreateClusterProperties type CreateClusterProperties struct { - // The name of your cluster. Must be 63 characters or less and must begin and end with an alphanumeric character ([a-z0-9A-Z]) with dashes (-), underscores (_), dots (.), and alphanumerics between. + // The name of your cluster. Must be 63 characters or less and must begin and end with an alphanumeric character (`[a-z0-9A-Z]`) with dashes (`-`), underscores (`_`), dots (`.`), and alphanumerics between. Name *string `json:"name"` - // The version of the DataPlatform. + // The version of the data platform. DataPlatformVersion *string `json:"dataPlatformVersion,omitempty"` // The UUID of the virtual data center (VDC) the cluster is provisioned. DatacenterId *string `json:"datacenterId"` MaintenanceWindow *MaintenanceWindow `json:"maintenanceWindow,omitempty"` + // A list of LANs you want this node pool to be part of. + Lans *[]Lan `json:"lans,omitempty"` } // NewCreateClusterProperties instantiates a new CreateClusterProperties object @@ -198,6 +200,44 @@ func (o *CreateClusterProperties) HasMaintenanceWindow() bool { return false } +// GetLans returns the Lans field value +// If the value is explicit nil, the zero value for []Lan will be returned +func (o *CreateClusterProperties) GetLans() *[]Lan { + if o == nil { + return nil + } + + return o.Lans + +} + +// GetLansOk returns a tuple with the Lans field value +// and a boolean to check if the value has been set. +// NOTE: If the value is an explicit nil, `nil, true` will be returned +func (o *CreateClusterProperties) GetLansOk() (*[]Lan, bool) { + if o == nil { + return nil, false + } + + return o.Lans, true +} + +// SetLans sets field value +func (o *CreateClusterProperties) SetLans(v []Lan) { + + o.Lans = &v + +} + +// HasLans returns a boolean if a field has been set. +func (o *CreateClusterProperties) HasLans() bool { + if o != nil && o.Lans != nil { + return true + } + + return false +} + func (o CreateClusterProperties) MarshalJSON() ([]byte, error) { toSerialize := map[string]interface{}{} if o.Name != nil { @@ -216,6 +256,10 @@ func (o CreateClusterProperties) MarshalJSON() ([]byte, error) { toSerialize["maintenanceWindow"] = o.MaintenanceWindow } + if o.Lans != nil { + toSerialize["lans"] = o.Lans + } + return json.Marshal(toSerialize) } diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_create_cluster_request.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_create_cluster_request.go index 5a80a585a..7bd46e7fa 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_create_cluster_request.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_create_cluster_request.go @@ -1,9 +1,9 @@ /* * IONOS Cloud - Managed Stackable Data Platform API * - * Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable Platform. Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the \"Data Center Designer\" (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Datacenter (VDC) The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS-CLI the following way: ``` ionosctl token generate ``` For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) ### Create a new DataPlatformCluster Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use-case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Service To create the desired application, the Stackable service needs to be provided, using the received kubeconfig and [deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic-Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) ### API-Key as Bearer Token The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. (See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. ### Permissions and access roles Currently, an admin can see and manipulate all resources in a contract. A normal authenticated user can only see and manipulate resources he created. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC and can only be modified or deleted via the API. ### References + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References * - * API version: 0.0.7 + * API version: 1.1.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -14,7 +14,7 @@ import ( "encoding/json" ) -// CreateClusterRequest Data to create a new DataPlatformCluster +// CreateClusterRequest Data to create a new DataPlatformCluster. type CreateClusterRequest struct { Properties *CreateClusterProperties `json:"properties"` } diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_create_node_pool_properties.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_create_node_pool_properties.go index d09dceffd..c79ac842c 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_create_node_pool_properties.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_create_node_pool_properties.go @@ -1,9 +1,9 @@ /* * IONOS Cloud - Managed Stackable Data Platform API * - * Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable Platform. Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the \"Data Center Designer\" (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Datacenter (VDC) The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS-CLI the following way: ``` ionosctl token generate ``` For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) ### Create a new DataPlatformCluster Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use-case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Service To create the desired application, the Stackable service needs to be provided, using the received kubeconfig and [deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic-Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) ### API-Key as Bearer Token The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. (See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. ### Permissions and access roles Currently, an admin can see and manipulate all resources in a contract. A normal authenticated user can only see and manipulate resources he created. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC and can only be modified or deleted via the API. ### References + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References * - * API version: 0.0.7 + * API version: 1.1.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -16,11 +16,11 @@ import ( // CreateNodePoolProperties struct for CreateNodePoolProperties type CreateNodePoolProperties struct { - // The name of your node pool. Must be 63 characters or less and must begin and end with an alphanumeric character ([a-z0-9A-Z]) with dashes (-), underscores (_), dots (.), and alphanumerics between. + // The name of your node pool. Must be 63 characters or less and must begin and end with an alphanumeric character (`[a-z0-9A-Z]`) with dashes (`-`), underscores (`_`), dots (`.`), and alphanumerics between. Name *string `json:"name"` // The number of nodes that make up the node pool. NodeCount *int32 `json:"nodeCount"` - // A valid CPU family name or `AUTO` if the platform shall choose the best fitting option. Available CPU architectures can be retrieved from the datacenter resource. + // A valid CPU family name or `AUTO` if the platform shall choose the best fitting option. Available CPU architectures can be retrieved from the data center resource. CpuFamily *string `json:"cpuFamily,omitempty"` // The number of CPU cores per node. CoresCount *int32 `json:"coresCount,omitempty"` @@ -28,12 +28,12 @@ type CreateNodePoolProperties struct { RamSize *int32 `json:"ramSize,omitempty"` AvailabilityZone *AvailabilityZone `json:"availabilityZone,omitempty"` StorageType *StorageType `json:"storageType,omitempty"` - // The size of the volume in GB. The size must be greater than 10GB. + // The size of the volume in GB. The size must be greater than 10 GB. StorageSize *int32 `json:"storageSize,omitempty"` MaintenanceWindow *MaintenanceWindow `json:"maintenanceWindow,omitempty"` - // Key-value pairs attached to the node pool resource as [Kubernetes labels](https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/) + // Key-value pairs attached to the node pool resource as [Kubernetes labels](https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/). Labels *map[string]interface{} `json:"labels,omitempty"` - // Key-value pairs attached to node pool resource as [Kubernetes annotations](https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/) + // Key-value pairs attached to node pool resource as [Kubernetes annotations](https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/). Annotations *map[string]interface{} `json:"annotations,omitempty"` } @@ -52,9 +52,9 @@ func NewCreateNodePoolProperties(name string, nodeCount int32) *CreateNodePoolPr this.CoresCount = &coresCount var ramSize int32 = 4096 this.RamSize = &ramSize - var availabilityZone AvailabilityZone = AUTO + var availabilityZone AvailabilityZone = AVAILABILITYZONE_AUTO this.AvailabilityZone = &availabilityZone - var storageType StorageType = SSD + var storageType StorageType = STORAGETYPE_SSD this.StorageType = &storageType var storageSize int32 = 20 this.StorageSize = &storageSize @@ -73,9 +73,9 @@ func NewCreateNodePoolPropertiesWithDefaults() *CreateNodePoolProperties { this.CoresCount = &coresCount var ramSize int32 = 4096 this.RamSize = &ramSize - var availabilityZone AvailabilityZone = AUTO + var availabilityZone AvailabilityZone = AVAILABILITYZONE_AUTO this.AvailabilityZone = &availabilityZone - var storageType StorageType = SSD + var storageType StorageType = STORAGETYPE_SSD this.StorageType = &storageType var storageSize int32 = 20 this.StorageSize = &storageSize diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_create_node_pool_request.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_create_node_pool_request.go index c14e8d7c7..9d8b4525a 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_create_node_pool_request.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_create_node_pool_request.go @@ -1,9 +1,9 @@ /* * IONOS Cloud - Managed Stackable Data Platform API * - * Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable Platform. Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the \"Data Center Designer\" (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Datacenter (VDC) The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS-CLI the following way: ``` ionosctl token generate ``` For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) ### Create a new DataPlatformCluster Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use-case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Service To create the desired application, the Stackable service needs to be provided, using the received kubeconfig and [deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic-Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) ### API-Key as Bearer Token The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. (See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. ### Permissions and access roles Currently, an admin can see and manipulate all resources in a contract. A normal authenticated user can only see and manipulate resources he created. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC and can only be modified or deleted via the API. ### References + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References * - * API version: 0.0.7 + * API version: 1.1.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -14,7 +14,7 @@ import ( "encoding/json" ) -// CreateNodePoolRequest Data to create a new node pool for a DataPlatformNodePool +// CreateNodePoolRequest Data to create a new node pool for a DataPlatformNodePool. type CreateNodePoolRequest struct { Properties *CreateNodePoolProperties `json:"properties"` } diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_error_message.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_error_message.go index d2532b437..03305d7bd 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_error_message.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_error_message.go @@ -1,9 +1,9 @@ /* * IONOS Cloud - Managed Stackable Data Platform API * - * Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable Platform. Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the \"Data Center Designer\" (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Datacenter (VDC) The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS-CLI the following way: ``` ionosctl token generate ``` For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) ### Create a new DataPlatformCluster Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use-case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Service To create the desired application, the Stackable service needs to be provided, using the received kubeconfig and [deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic-Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) ### API-Key as Bearer Token The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. (See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. ### Permissions and access roles Currently, an admin can see and manipulate all resources in a contract. A normal authenticated user can only see and manipulate resources he created. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC and can only be modified or deleted via the API. ### References + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References * - * API version: 0.0.7 + * API version: 1.1.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -16,7 +16,7 @@ import ( // ErrorMessage struct for ErrorMessage type ErrorMessage struct { - // internal error code + // Internal error code. ErrorCode *string `json:"errorCode,omitempty"` // A human readable explanation of the problem. Message *string `json:"message,omitempty"` diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_error_response.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_error_response.go index a0a26b76e..2157c7422 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_error_response.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_error_response.go @@ -1,9 +1,9 @@ /* * IONOS Cloud - Managed Stackable Data Platform API * - * Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable Platform. Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the \"Data Center Designer\" (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Datacenter (VDC) The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS-CLI the following way: ``` ionosctl token generate ``` For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) ### Create a new DataPlatformCluster Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use-case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Service To create the desired application, the Stackable service needs to be provided, using the received kubeconfig and [deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic-Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) ### API-Key as Bearer Token The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. (See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. ### Permissions and access roles Currently, an admin can see and manipulate all resources in a contract. A normal authenticated user can only see and manipulate resources he created. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC and can only be modified or deleted via the API. ### References + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References * - * API version: 0.0.7 + * API version: 1.1.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -16,7 +16,7 @@ import ( // ErrorResponse struct for ErrorResponse type ErrorResponse struct { - // HTTP status code of the operation as specified by [RFC 7231](https://datatracker.ietf.org/doc/html/rfc7231#section-6) + // HTTP status code of the operation as specified by [RFC 7231](https://datatracker.ietf.org/doc/html/rfc7231#section-6). HttpStatus *int32 `json:"httpStatus,omitempty"` Messages *[]ErrorMessage `json:"messages,omitempty"` } diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_lan.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_lan.go new file mode 100644 index 000000000..f21dc9b68 --- /dev/null +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_lan.go @@ -0,0 +1,212 @@ +/* + * IONOS Cloud - Managed Stackable Data Platform API + * + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References + * + * API version: 1.1.0 + */ + +// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. + +package ionoscloud + +import ( + "encoding/json" +) + +// Lan Local area network. +type Lan struct { + // The LAN ID of an existing LAN at the related data center. + LanId *string `json:"lanId"` + // Indicates if the Kubernetes node pool LAN will reserve an IP using DHCP. The default value is `true`. + Dhcp *bool `json:"dhcp,omitempty"` + // An array of additional LANs attached to worker nodes. + Routes *[]Route `json:"routes,omitempty"` +} + +// NewLan instantiates a new Lan object +// This constructor will assign default values to properties that have it defined, +// and makes sure properties required by API are set, but the set of arguments +// will change when the set of required properties is changed +func NewLan(lanId string) *Lan { + this := Lan{} + + this.LanId = &lanId + + return &this +} + +// NewLanWithDefaults instantiates a new Lan object +// This constructor will only assign default values to properties that have it defined, +// but it doesn't guarantee that properties required by API are set +func NewLanWithDefaults() *Lan { + this := Lan{} + return &this +} + +// GetLanId returns the LanId field value +// If the value is explicit nil, the zero value for string will be returned +func (o *Lan) GetLanId() *string { + if o == nil { + return nil + } + + return o.LanId + +} + +// GetLanIdOk returns a tuple with the LanId field value +// and a boolean to check if the value has been set. +// NOTE: If the value is an explicit nil, `nil, true` will be returned +func (o *Lan) GetLanIdOk() (*string, bool) { + if o == nil { + return nil, false + } + + return o.LanId, true +} + +// SetLanId sets field value +func (o *Lan) SetLanId(v string) { + + o.LanId = &v + +} + +// HasLanId returns a boolean if a field has been set. +func (o *Lan) HasLanId() bool { + if o != nil && o.LanId != nil { + return true + } + + return false +} + +// GetDhcp returns the Dhcp field value +// If the value is explicit nil, the zero value for bool will be returned +func (o *Lan) GetDhcp() *bool { + if o == nil { + return nil + } + + return o.Dhcp + +} + +// GetDhcpOk returns a tuple with the Dhcp field value +// and a boolean to check if the value has been set. +// NOTE: If the value is an explicit nil, `nil, true` will be returned +func (o *Lan) GetDhcpOk() (*bool, bool) { + if o == nil { + return nil, false + } + + return o.Dhcp, true +} + +// SetDhcp sets field value +func (o *Lan) SetDhcp(v bool) { + + o.Dhcp = &v + +} + +// HasDhcp returns a boolean if a field has been set. +func (o *Lan) HasDhcp() bool { + if o != nil && o.Dhcp != nil { + return true + } + + return false +} + +// GetRoutes returns the Routes field value +// If the value is explicit nil, the zero value for []Route will be returned +func (o *Lan) GetRoutes() *[]Route { + if o == nil { + return nil + } + + return o.Routes + +} + +// GetRoutesOk returns a tuple with the Routes field value +// and a boolean to check if the value has been set. +// NOTE: If the value is an explicit nil, `nil, true` will be returned +func (o *Lan) GetRoutesOk() (*[]Route, bool) { + if o == nil { + return nil, false + } + + return o.Routes, true +} + +// SetRoutes sets field value +func (o *Lan) SetRoutes(v []Route) { + + o.Routes = &v + +} + +// HasRoutes returns a boolean if a field has been set. +func (o *Lan) HasRoutes() bool { + if o != nil && o.Routes != nil { + return true + } + + return false +} + +func (o Lan) MarshalJSON() ([]byte, error) { + toSerialize := map[string]interface{}{} + if o.LanId != nil { + toSerialize["lanId"] = o.LanId + } + + if o.Dhcp != nil { + toSerialize["dhcp"] = o.Dhcp + } + + if o.Routes != nil { + toSerialize["routes"] = o.Routes + } + + return json.Marshal(toSerialize) +} + +type NullableLan struct { + value *Lan + isSet bool +} + +func (v NullableLan) Get() *Lan { + return v.value +} + +func (v *NullableLan) Set(val *Lan) { + v.value = val + v.isSet = true +} + +func (v NullableLan) IsSet() bool { + return v.isSet +} + +func (v *NullableLan) Unset() { + v.value = nil + v.isSet = false +} + +func NewNullableLan(val *Lan) *NullableLan { + return &NullableLan{value: val, isSet: true} +} + +func (v NullableLan) MarshalJSON() ([]byte, error) { + return json.Marshal(v.value) +} + +func (v *NullableLan) UnmarshalJSON(src []byte) error { + v.isSet = true + return json.Unmarshal(src, &v.value) +} diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_maintenance_window.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_maintenance_window.go index b17bb64d9..b5136d62c 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_maintenance_window.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_maintenance_window.go @@ -1,9 +1,9 @@ /* * IONOS Cloud - Managed Stackable Data Platform API * - * Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable Platform. Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the \"Data Center Designer\" (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Datacenter (VDC) The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS-CLI the following way: ``` ionosctl token generate ``` For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) ### Create a new DataPlatformCluster Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use-case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Service To create the desired application, the Stackable service needs to be provided, using the received kubeconfig and [deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic-Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) ### API-Key as Bearer Token The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. (See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. ### Permissions and access roles Currently, an admin can see and manipulate all resources in a contract. A normal authenticated user can only see and manipulate resources he created. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC and can only be modified or deleted via the API. ### References + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References * - * API version: 0.0.7 + * API version: 1.1.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -14,9 +14,9 @@ import ( "encoding/json" ) -// MaintenanceWindow Starting time of a weekly 4 hour-long window, during which maintenance might occur in hh:mm:ss format +// MaintenanceWindow Starting time of a weekly 4-hour-long window, during which maintenance might occur in the `HH:MM:SS` format. type MaintenanceWindow struct { - // Time at which the maintenance should start. Must conform to the 'HH:MM:SS' 24-hour format. + // Time at which the maintenance should start. Must conform to the `HH:MM:SS` 24-hour format. Time *string `json:"time"` DayOfTheWeek *string `json:"dayOfTheWeek"` } diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_metadata.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_metadata.go index 5b42c12a9..2f4ef46fc 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_metadata.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_metadata.go @@ -1,9 +1,9 @@ /* * IONOS Cloud - Managed Stackable Data Platform API * - * Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable Platform. Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the \"Data Center Designer\" (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Datacenter (VDC) The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS-CLI the following way: ``` ionosctl token generate ``` For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) ### Create a new DataPlatformCluster Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use-case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Service To create the desired application, the Stackable service needs to be provided, using the received kubeconfig and [deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic-Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) ### API-Key as Bearer Token The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. (See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. ### Permissions and access roles Currently, an admin can see and manipulate all resources in a contract. A normal authenticated user can only see and manipulate resources he created. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC and can only be modified or deleted via the API. ### References + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References * - * API version: 0.0.7 + * API version: 1.1.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -15,31 +15,31 @@ import ( "time" ) -// Metadata Metadata of the resource +// Metadata Metadata of the resource. type Metadata struct { - // The Entity Tag of the resource as defined in http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.11 + // The *entity tag* of the resource as defined in [RFC 9110](https://www.rfc-editor.org/rfc/rfc9110.html#name-etag). ETag *string `json:"ETag,omitempty"` // The time the resource was created, ISO 8601 timestamp (UTC). CreatedDate *IonosTime `json:"createdDate,omitempty"` - // The user that created the resource + // The user that created the resource. CreatedBy *string `json:"createdBy,omitempty"` - // The ID of the user that created the resource + // The ID of the user that created the resource. CreatedByUserId *string `json:"createdByUserId,omitempty"` - // The creators contractNumber + // The creators' contract number. CreatedInContractNumber *string `json:"createdInContractNumber,omitempty"` // The last time the resource was modified, ISO 8601 timestamp (UTC). LastModifiedDate *IonosTime `json:"lastModifiedDate,omitempty"` - // The user that last modified the resource + // The user that last modified the resource. LastModifiedBy *string `json:"lastModifiedBy,omitempty"` - // The ID of the user that last modified the resource + // The ID of the user that last modified the resource. LastModifiedByUserId *string `json:"lastModifiedByUserId,omitempty"` - // The version of the DataPlatform. + // The version of the data platform. CurrentDataPlatformVersion *string `json:"currentDataPlatformVersion,omitempty"` - // The current dataplatform revision of a resource. This internal revision is used to rollout non-breaking internal changes. This attribute is read-only. + // The current data platform revision of a resource. This internal revision is used to roll out non-breaking internal changes. This attribute is read-only. CurrentDataPlatformRevision *int64 `json:"currentDataPlatformRevision,omitempty"` - // List of available upgrades for this cluster + // List of available upgrades for this cluster. AvailableUpgradeVersions *[]string `json:"availableUpgradeVersions,omitempty"` - // State of the resource. *AVAILABLE* There are no pending modification requests for this item; *BUSY* There is at least one modification request pending and all following requests will be queued; *DEPLOYING* Resource state DEPLOYING - the resource is being created; *FAILED* Resource state FAILED - creation of the resource failed; *UPDATING* Resource state UPDATING - the resource is being updated; *FAILED_UPDATING* Resource state FAILED_UPDATING - an update to the resource was not successful; *DESTROYING* Resource state DESTROYING - the resource is being deleted; *FAILED_DESTROYING* Resource state FAILED_DESTROYING - deletion of the resource was not successful; *TERMINATED* Resource state TERMINATED - the resource was deleted. + // State of the resource. Resource states: `AVAILABLE`: There are no pending modification requests for this item. `BUSY`: There is at least one modification request pending and all following requests will be queued. `DEPLOYING`: The resource is being created. `FAILED`: The creation of the resource failed. `UPDATING`: The resource is being updated. `FAILED_UPDATING`: An update to the resource was not successful. `DESTROYING`: The resource is being deleted. `FAILED_DESTROYING`: The deletion of the resource was not successful. `TERMINATED`: The resource has been deleted. State *string `json:"state,omitempty"` } diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_node_pool.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_node_pool.go index f74b7b7b9..d721365e4 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_node_pool.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_node_pool.go @@ -1,9 +1,9 @@ /* * IONOS Cloud - Managed Stackable Data Platform API * - * Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable Platform. Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the \"Data Center Designer\" (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Datacenter (VDC) The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS-CLI the following way: ``` ionosctl token generate ``` For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) ### Create a new DataPlatformCluster Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use-case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Service To create the desired application, the Stackable service needs to be provided, using the received kubeconfig and [deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic-Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) ### API-Key as Bearer Token The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. (See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. ### Permissions and access roles Currently, an admin can see and manipulate all resources in a contract. A normal authenticated user can only see and manipulate resources he created. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC and can only be modified or deleted via the API. ### References + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References * - * API version: 0.0.7 + * API version: 1.1.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -14,17 +14,17 @@ import ( "encoding/json" ) -// NodePool A DataPlatformNodePool of a DataPlatformCluster +// NodePool A DataPlatformNodePool of a DataPlatformCluster. type NodePool struct { - // The name of your node pool. Must be 63 characters or less and must begin and end with an alphanumeric character ([a-z0-9A-Z]) with dashes (-), underscores (_), dots (.), and alphanumerics between. + // The name of your node pool. Must be 63 characters or less and must begin and end with an alphanumeric character (`[a-z0-9A-Z]`) with dashes (`-`), underscores (`_`), dots (`.`), and alphanumerics between. Name *string `json:"name,omitempty"` - // The version of the DataPlatform. + // The version of the data platform. DataPlatformVersion *string `json:"dataPlatformVersion,omitempty"` // The UUID of the virtual data center (VDC) the cluster is provisioned. DatacenterId *string `json:"datacenterId,omitempty"` // The number of nodes that make up the node pool. NodeCount *int32 `json:"nodeCount,omitempty"` - // A valid CPU family name or `AUTO` if the platform shall choose the best fitting option. Available CPU architectures can be retrieved from the datacenter resource. + // A valid CPU family name or `AUTO` if the platform shall choose the best fitting option. Available CPU architectures can be retrieved from the data center resource. CpuFamily *string `json:"cpuFamily,omitempty"` // The number of CPU cores per node. CoresCount *int32 `json:"coresCount,omitempty"` @@ -32,12 +32,12 @@ type NodePool struct { RamSize *int32 `json:"ramSize,omitempty"` AvailabilityZone *AvailabilityZone `json:"availabilityZone,omitempty"` StorageType *StorageType `json:"storageType,omitempty"` - // The size of the volume in GB. The size must be greater than 10GB. + // The size of the volume in GB. The size must be greater than 10 GB. StorageSize *int32 `json:"storageSize,omitempty"` MaintenanceWindow *MaintenanceWindow `json:"maintenanceWindow,omitempty"` - // Key-value pairs attached to the node pool resource as [Kubernetes labels](https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/) + // Key-value pairs attached to the node pool resource as [Kubernetes labels](https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/). Labels *map[string]interface{} `json:"labels,omitempty"` - // Key-value pairs attached to node pool resource as [Kubernetes annotations](https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/) + // Key-value pairs attached to node pool resource as [Kubernetes annotations](https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/). Annotations *map[string]interface{} `json:"annotations,omitempty"` } @@ -54,9 +54,9 @@ func NewNodePool() *NodePool { this.CoresCount = &coresCount var ramSize int32 = 4096 this.RamSize = &ramSize - var availabilityZone AvailabilityZone = AUTO + var availabilityZone AvailabilityZone = AVAILABILITYZONE_AUTO this.AvailabilityZone = &availabilityZone - var storageType StorageType = SSD + var storageType StorageType = STORAGETYPE_SSD this.StorageType = &storageType var storageSize int32 = 20 this.StorageSize = &storageSize @@ -75,9 +75,9 @@ func NewNodePoolWithDefaults() *NodePool { this.CoresCount = &coresCount var ramSize int32 = 4096 this.RamSize = &ramSize - var availabilityZone AvailabilityZone = AUTO + var availabilityZone AvailabilityZone = AVAILABILITYZONE_AUTO this.AvailabilityZone = &availabilityZone - var storageType StorageType = SSD + var storageType StorageType = STORAGETYPE_SSD this.StorageType = &storageType var storageSize int32 = 20 this.StorageSize = &storageSize diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_node_pool_list_response_data.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_node_pool_list_response_data.go index 32f61e20d..4184c7ad7 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_node_pool_list_response_data.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_node_pool_list_response_data.go @@ -1,9 +1,9 @@ /* * IONOS Cloud - Managed Stackable Data Platform API * - * Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable Platform. Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the \"Data Center Designer\" (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Datacenter (VDC) The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS-CLI the following way: ``` ionosctl token generate ``` For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) ### Create a new DataPlatformCluster Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use-case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Service To create the desired application, the Stackable service needs to be provided, using the received kubeconfig and [deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic-Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) ### API-Key as Bearer Token The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. (See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. ### Permissions and access roles Currently, an admin can see and manipulate all resources in a contract. A normal authenticated user can only see and manipulate resources he created. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC and can only be modified or deleted via the API. ### References + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References * - * API version: 0.0.7 + * API version: 1.1.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -14,7 +14,7 @@ import ( "encoding/json" ) -// NodePoolListResponseData Data of a node pool list +// NodePoolListResponseData Data of a node pool list. type NodePoolListResponseData struct { // The ID of a list of resources. Id *string `json:"id,omitempty"` diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_node_pool_response_data.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_node_pool_response_data.go index 01aa35170..d2f2941dd 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_node_pool_response_data.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_node_pool_response_data.go @@ -1,9 +1,9 @@ /* * IONOS Cloud - Managed Stackable Data Platform API * - * Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable Platform. Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the \"Data Center Designer\" (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Datacenter (VDC) The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS-CLI the following way: ``` ionosctl token generate ``` For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) ### Create a new DataPlatformCluster Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use-case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Service To create the desired application, the Stackable service needs to be provided, using the received kubeconfig and [deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic-Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) ### API-Key as Bearer Token The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. (See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. ### Permissions and access roles Currently, an admin can see and manipulate all resources in a contract. A normal authenticated user can only see and manipulate resources he created. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC and can only be modified or deleted via the API. ### References + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References * - * API version: 0.0.7 + * API version: 1.1.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -14,7 +14,7 @@ import ( "encoding/json" ) -// NodePoolResponseData Data of a node pool +// NodePoolResponseData Data of a node pool. type NodePoolResponseData struct { // The unique ID of the resource. Must conform to the UUID format. Id *string `json:"id"` diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_patch_cluster_properties.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_patch_cluster_properties.go index 5def16107..af198313f 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_patch_cluster_properties.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_patch_cluster_properties.go @@ -1,9 +1,9 @@ /* * IONOS Cloud - Managed Stackable Data Platform API * - * Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable Platform. Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the \"Data Center Designer\" (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Datacenter (VDC) The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS-CLI the following way: ``` ionosctl token generate ``` For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) ### Create a new DataPlatformCluster Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use-case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Service To create the desired application, the Stackable service needs to be provided, using the received kubeconfig and [deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic-Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) ### API-Key as Bearer Token The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. (See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. ### Permissions and access roles Currently, an admin can see and manipulate all resources in a contract. A normal authenticated user can only see and manipulate resources he created. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC and can only be modified or deleted via the API. ### References + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References * - * API version: 0.0.7 + * API version: 1.1.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -16,11 +16,13 @@ import ( // PatchClusterProperties struct for PatchClusterProperties type PatchClusterProperties struct { - // The name of your cluster. Must be 63 characters or less and must begin and end with an alphanumeric character ([a-z0-9A-Z]) with dashes (-), underscores (_), dots (.), and alphanumerics between. + // The name of your cluster. Must be 63 characters or less and must begin and end with an alphanumeric character (`[a-z0-9A-Z]`) with dashes (`-`), underscores (`_`), dots (`.`), and alphanumerics between. Name *string `json:"name,omitempty"` - // The version of the DataPlatform. + // The version of the data platform. DataPlatformVersion *string `json:"dataPlatformVersion,omitempty"` MaintenanceWindow *MaintenanceWindow `json:"maintenanceWindow,omitempty"` + // A list of LANs you want this cluster to be part of. + Lans *[]Lan `json:"lans,omitempty"` } // NewPatchClusterProperties instantiates a new PatchClusterProperties object @@ -155,6 +157,44 @@ func (o *PatchClusterProperties) HasMaintenanceWindow() bool { return false } +// GetLans returns the Lans field value +// If the value is explicit nil, the zero value for []Lan will be returned +func (o *PatchClusterProperties) GetLans() *[]Lan { + if o == nil { + return nil + } + + return o.Lans + +} + +// GetLansOk returns a tuple with the Lans field value +// and a boolean to check if the value has been set. +// NOTE: If the value is an explicit nil, `nil, true` will be returned +func (o *PatchClusterProperties) GetLansOk() (*[]Lan, bool) { + if o == nil { + return nil, false + } + + return o.Lans, true +} + +// SetLans sets field value +func (o *PatchClusterProperties) SetLans(v []Lan) { + + o.Lans = &v + +} + +// HasLans returns a boolean if a field has been set. +func (o *PatchClusterProperties) HasLans() bool { + if o != nil && o.Lans != nil { + return true + } + + return false +} + func (o PatchClusterProperties) MarshalJSON() ([]byte, error) { toSerialize := map[string]interface{}{} if o.Name != nil { @@ -169,6 +209,8 @@ func (o PatchClusterProperties) MarshalJSON() ([]byte, error) { toSerialize["maintenanceWindow"] = o.MaintenanceWindow } + toSerialize["lans"] = o.Lans + return json.Marshal(toSerialize) } diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_patch_cluster_request.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_patch_cluster_request.go index 761e8bc7b..27032b68b 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_patch_cluster_request.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_patch_cluster_request.go @@ -1,9 +1,9 @@ /* * IONOS Cloud - Managed Stackable Data Platform API * - * Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable Platform. Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the \"Data Center Designer\" (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Datacenter (VDC) The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS-CLI the following way: ``` ionosctl token generate ``` For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) ### Create a new DataPlatformCluster Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use-case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Service To create the desired application, the Stackable service needs to be provided, using the received kubeconfig and [deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic-Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) ### API-Key as Bearer Token The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. (See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. ### Permissions and access roles Currently, an admin can see and manipulate all resources in a contract. A normal authenticated user can only see and manipulate resources he created. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC and can only be modified or deleted via the API. ### References + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References * - * API version: 0.0.7 + * API version: 1.1.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -14,7 +14,7 @@ import ( "encoding/json" ) -// PatchClusterRequest Data to update selected properties of a DataPlatformCluster +// PatchClusterRequest Data to update selected properties of a DataPlatformCluster. type PatchClusterRequest struct { Properties *PatchClusterProperties `json:"properties"` } diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_patch_node_pool_properties.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_patch_node_pool_properties.go index fdaa1db97..b25795268 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_patch_node_pool_properties.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_patch_node_pool_properties.go @@ -1,9 +1,9 @@ /* * IONOS Cloud - Managed Stackable Data Platform API * - * Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable Platform. Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the \"Data Center Designer\" (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Datacenter (VDC) The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS-CLI the following way: ``` ionosctl token generate ``` For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) ### Create a new DataPlatformCluster Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use-case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Service To create the desired application, the Stackable service needs to be provided, using the received kubeconfig and [deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic-Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) ### API-Key as Bearer Token The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. (See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. ### Permissions and access roles Currently, an admin can see and manipulate all resources in a contract. A normal authenticated user can only see and manipulate resources he created. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC and can only be modified or deleted via the API. ### References + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References * - * API version: 0.0.7 + * API version: 1.1.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -19,9 +19,9 @@ type PatchNodePoolProperties struct { // The number of nodes that make up the node pool. NodeCount *int32 `json:"nodeCount,omitempty"` MaintenanceWindow *MaintenanceWindow `json:"maintenanceWindow,omitempty"` - // Key-value pairs attached to the node pool resource as [Kubernetes labels](https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/) + // Key-value pairs attached to the node pool resource as [Kubernetes labels](https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/). Labels *map[string]interface{} `json:"labels,omitempty"` - // Key-value pairs attached to node pool resource as [Kubernetes annotations](https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/) + // Key-value pairs attached to node pool resource as [Kubernetes annotations](https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/). Annotations *map[string]interface{} `json:"annotations,omitempty"` } diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_patch_node_pool_request.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_patch_node_pool_request.go index 9a05fba84..9fb1f7b1b 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_patch_node_pool_request.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_patch_node_pool_request.go @@ -1,9 +1,9 @@ /* * IONOS Cloud - Managed Stackable Data Platform API * - * Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable Platform. Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the \"Data Center Designer\" (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Datacenter (VDC) The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS-CLI the following way: ``` ionosctl token generate ``` For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) ### Create a new DataPlatformCluster Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use-case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Service To create the desired application, the Stackable service needs to be provided, using the received kubeconfig and [deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic-Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) ### API-Key as Bearer Token The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. (See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. ### Permissions and access roles Currently, an admin can see and manipulate all resources in a contract. A normal authenticated user can only see and manipulate resources he created. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC and can only be modified or deleted via the API. ### References + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References * - * API version: 0.0.7 + * API version: 1.1.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_route.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_route.go new file mode 100644 index 000000000..e801b503e --- /dev/null +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_route.go @@ -0,0 +1,169 @@ +/* + * IONOS Cloud - Managed Stackable Data Platform API + * + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References + * + * API version: 1.1.0 + */ + +// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. + +package ionoscloud + +import ( + "encoding/json" +) + +// Route A LAN route. +type Route struct { + // IPv4 or IPv6 CIDR to be routed via the interface. + Network *string `json:"network"` + // IPv4 or IPv6 gateway IP for the route. + Gateway *string `json:"gateway"` +} + +// NewRoute instantiates a new Route object +// This constructor will assign default values to properties that have it defined, +// and makes sure properties required by API are set, but the set of arguments +// will change when the set of required properties is changed +func NewRoute(network string, gateway string) *Route { + this := Route{} + + this.Network = &network + this.Gateway = &gateway + + return &this +} + +// NewRouteWithDefaults instantiates a new Route object +// This constructor will only assign default values to properties that have it defined, +// but it doesn't guarantee that properties required by API are set +func NewRouteWithDefaults() *Route { + this := Route{} + return &this +} + +// GetNetwork returns the Network field value +// If the value is explicit nil, the zero value for string will be returned +func (o *Route) GetNetwork() *string { + if o == nil { + return nil + } + + return o.Network + +} + +// GetNetworkOk returns a tuple with the Network field value +// and a boolean to check if the value has been set. +// NOTE: If the value is an explicit nil, `nil, true` will be returned +func (o *Route) GetNetworkOk() (*string, bool) { + if o == nil { + return nil, false + } + + return o.Network, true +} + +// SetNetwork sets field value +func (o *Route) SetNetwork(v string) { + + o.Network = &v + +} + +// HasNetwork returns a boolean if a field has been set. +func (o *Route) HasNetwork() bool { + if o != nil && o.Network != nil { + return true + } + + return false +} + +// GetGateway returns the Gateway field value +// If the value is explicit nil, the zero value for string will be returned +func (o *Route) GetGateway() *string { + if o == nil { + return nil + } + + return o.Gateway + +} + +// GetGatewayOk returns a tuple with the Gateway field value +// and a boolean to check if the value has been set. +// NOTE: If the value is an explicit nil, `nil, true` will be returned +func (o *Route) GetGatewayOk() (*string, bool) { + if o == nil { + return nil, false + } + + return o.Gateway, true +} + +// SetGateway sets field value +func (o *Route) SetGateway(v string) { + + o.Gateway = &v + +} + +// HasGateway returns a boolean if a field has been set. +func (o *Route) HasGateway() bool { + if o != nil && o.Gateway != nil { + return true + } + + return false +} + +func (o Route) MarshalJSON() ([]byte, error) { + toSerialize := map[string]interface{}{} + if o.Network != nil { + toSerialize["network"] = o.Network + } + + if o.Gateway != nil { + toSerialize["gateway"] = o.Gateway + } + + return json.Marshal(toSerialize) +} + +type NullableRoute struct { + value *Route + isSet bool +} + +func (v NullableRoute) Get() *Route { + return v.value +} + +func (v *NullableRoute) Set(val *Route) { + v.value = val + v.isSet = true +} + +func (v NullableRoute) IsSet() bool { + return v.isSet +} + +func (v *NullableRoute) Unset() { + v.value = nil + v.isSet = false +} + +func NewNullableRoute(val *Route) *NullableRoute { + return &NullableRoute{value: val, isSet: true} +} + +func (v NullableRoute) MarshalJSON() ([]byte, error) { + return json.Marshal(v.value) +} + +func (v *NullableRoute) UnmarshalJSON(src []byte) error { + v.isSet = true + return json.Unmarshal(src, &v.value) +} diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_storage_type.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_storage_type.go index 5df471d99..2735987df 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_storage_type.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_storage_type.go @@ -1,9 +1,9 @@ /* * IONOS Cloud - Managed Stackable Data Platform API * - * Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable Platform. Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the \"Data Center Designer\" (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Datacenter (VDC) The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS-CLI the following way: ``` ionosctl token generate ``` For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) ### Create a new DataPlatformCluster Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use-case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Service To create the desired application, the Stackable service needs to be provided, using the received kubeconfig and [deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic-Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) ### API-Key as Bearer Token The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. (See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. ### Permissions and access roles Currently, an admin can see and manipulate all resources in a contract. A normal authenticated user can only see and manipulate resources he created. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC and can only be modified or deleted via the API. ### References + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References * - * API version: 0.0.7 + * API version: 1.1.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -20,8 +20,8 @@ type StorageType string // List of StorageType const ( - HDD StorageType = "HDD" - SSD StorageType = "SSD" + STORAGETYPE_HDD StorageType = "HDD" + STORAGETYPE_SSD StorageType = "SSD" ) func (v *StorageType) UnmarshalJSON(src []byte) error { diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_versions_get_200_response.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_versions_get_200_response.go new file mode 100644 index 000000000..d79b7d5cf --- /dev/null +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_versions_get_200_response.go @@ -0,0 +1,253 @@ +/* + * IONOS Cloud - Managed Stackable Data Platform API + * + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References + * + * API version: 1.1.0 + */ + +// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. + +package ionoscloud + +import ( + "encoding/json" +) + +// VersionsGet200Response struct for VersionsGet200Response +type VersionsGet200Response struct { + // The ID of a list of resources. + Id *string `json:"id,omitempty"` + Type *string `json:"type,omitempty"` + Href *string `json:"href,omitempty"` + Items *[]string `json:"items"` +} + +// NewVersionsGet200Response instantiates a new VersionsGet200Response object +// This constructor will assign default values to properties that have it defined, +// and makes sure properties required by API are set, but the set of arguments +// will change when the set of required properties is changed +func NewVersionsGet200Response(items []string) *VersionsGet200Response { + this := VersionsGet200Response{} + + this.Items = &items + + return &this +} + +// NewVersionsGet200ResponseWithDefaults instantiates a new VersionsGet200Response object +// This constructor will only assign default values to properties that have it defined, +// but it doesn't guarantee that properties required by API are set +func NewVersionsGet200ResponseWithDefaults() *VersionsGet200Response { + this := VersionsGet200Response{} + return &this +} + +// GetId returns the Id field value +// If the value is explicit nil, the zero value for string will be returned +func (o *VersionsGet200Response) GetId() *string { + if o == nil { + return nil + } + + return o.Id + +} + +// GetIdOk returns a tuple with the Id field value +// and a boolean to check if the value has been set. +// NOTE: If the value is an explicit nil, `nil, true` will be returned +func (o *VersionsGet200Response) GetIdOk() (*string, bool) { + if o == nil { + return nil, false + } + + return o.Id, true +} + +// SetId sets field value +func (o *VersionsGet200Response) SetId(v string) { + + o.Id = &v + +} + +// HasId returns a boolean if a field has been set. +func (o *VersionsGet200Response) HasId() bool { + if o != nil && o.Id != nil { + return true + } + + return false +} + +// GetType returns the Type field value +// If the value is explicit nil, the zero value for string will be returned +func (o *VersionsGet200Response) GetType() *string { + if o == nil { + return nil + } + + return o.Type + +} + +// GetTypeOk returns a tuple with the Type field value +// and a boolean to check if the value has been set. +// NOTE: If the value is an explicit nil, `nil, true` will be returned +func (o *VersionsGet200Response) GetTypeOk() (*string, bool) { + if o == nil { + return nil, false + } + + return o.Type, true +} + +// SetType sets field value +func (o *VersionsGet200Response) SetType(v string) { + + o.Type = &v + +} + +// HasType returns a boolean if a field has been set. +func (o *VersionsGet200Response) HasType() bool { + if o != nil && o.Type != nil { + return true + } + + return false +} + +// GetHref returns the Href field value +// If the value is explicit nil, the zero value for string will be returned +func (o *VersionsGet200Response) GetHref() *string { + if o == nil { + return nil + } + + return o.Href + +} + +// GetHrefOk returns a tuple with the Href field value +// and a boolean to check if the value has been set. +// NOTE: If the value is an explicit nil, `nil, true` will be returned +func (o *VersionsGet200Response) GetHrefOk() (*string, bool) { + if o == nil { + return nil, false + } + + return o.Href, true +} + +// SetHref sets field value +func (o *VersionsGet200Response) SetHref(v string) { + + o.Href = &v + +} + +// HasHref returns a boolean if a field has been set. +func (o *VersionsGet200Response) HasHref() bool { + if o != nil && o.Href != nil { + return true + } + + return false +} + +// GetItems returns the Items field value +// If the value is explicit nil, the zero value for []string will be returned +func (o *VersionsGet200Response) GetItems() *[]string { + if o == nil { + return nil + } + + return o.Items + +} + +// GetItemsOk returns a tuple with the Items field value +// and a boolean to check if the value has been set. +// NOTE: If the value is an explicit nil, `nil, true` will be returned +func (o *VersionsGet200Response) GetItemsOk() (*[]string, bool) { + if o == nil { + return nil, false + } + + return o.Items, true +} + +// SetItems sets field value +func (o *VersionsGet200Response) SetItems(v []string) { + + o.Items = &v + +} + +// HasItems returns a boolean if a field has been set. +func (o *VersionsGet200Response) HasItems() bool { + if o != nil && o.Items != nil { + return true + } + + return false +} + +func (o VersionsGet200Response) MarshalJSON() ([]byte, error) { + toSerialize := map[string]interface{}{} + if o.Id != nil { + toSerialize["id"] = o.Id + } + + if o.Type != nil { + toSerialize["type"] = o.Type + } + + if o.Href != nil { + toSerialize["href"] = o.Href + } + + if o.Items != nil { + toSerialize["items"] = o.Items + } + + return json.Marshal(toSerialize) +} + +type NullableVersionsGet200Response struct { + value *VersionsGet200Response + isSet bool +} + +func (v NullableVersionsGet200Response) Get() *VersionsGet200Response { + return v.value +} + +func (v *NullableVersionsGet200Response) Set(val *VersionsGet200Response) { + v.value = val + v.isSet = true +} + +func (v NullableVersionsGet200Response) IsSet() bool { + return v.isSet +} + +func (v *NullableVersionsGet200Response) Unset() { + v.value = nil + v.isSet = false +} + +func NewNullableVersionsGet200Response(val *VersionsGet200Response) *NullableVersionsGet200Response { + return &NullableVersionsGet200Response{value: val, isSet: true} +} + +func (v NullableVersionsGet200Response) MarshalJSON() ([]byte, error) { + return json.Marshal(v.value) +} + +func (v *NullableVersionsGet200Response) UnmarshalJSON(src []byte) error { + v.isSet = true + return json.Unmarshal(src, &v.value) +} diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/response.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/response.go index 3681d2b1c..a2de7c8d7 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/response.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/response.go @@ -1,9 +1,9 @@ /* * IONOS Cloud - Managed Stackable Data Platform API * - * Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable Platform. Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the \"Data Center Designer\" (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Datacenter (VDC) The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS-CLI the following way: ``` ionosctl token generate ``` For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) ### Create a new DataPlatformCluster Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use-case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Service To create the desired application, the Stackable service needs to be provided, using the received kubeconfig and [deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic-Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) ### API-Key as Bearer Token The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. (See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. ### Permissions and access roles Currently, an admin can see and manipulate all resources in a contract. A normal authenticated user can only see and manipulate resources he created. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC and can only be modified or deleted via the API. ### References + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References * - * API version: 0.0.7 + * API version: 1.1.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. diff --git a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/utils.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/utils.go index 7d0dfd443..c2d2d2d2d 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/utils.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/utils.go @@ -1,9 +1,9 @@ /* * IONOS Cloud - Managed Stackable Data Platform API * - * Managed Stackable Data Platform by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable Platform. Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the \"Data Center Designer\" (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account** visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Datacenter (VDC) The Managed Data Stack needs a virtual datacenter (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed DataPlatform to other services already running within your VDC. Otherwise, if you want to place the Managed Data Stack in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS-CLI or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/tutorials/data-center-basics) ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS-CLI the following way: ``` ionosctl token generate ``` For more information [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) ### Create a new DataPlatformCluster Before using Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use-case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Service To create the desired application, the Stackable service needs to be provided, using the received kubeconfig and [deploy a Stackable service](https://docs.stackable.tech/home/getting_started.html#_deploying_stackable_services) ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic-Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a Basic Authentication Header accordingly to [RFC7617](https://datatracker.ietf.org/doc/html/rfc7617) ### API-Key as Bearer Token The Bearer auth token used at the API-Gateway is a user related token created with the IONOS-CLI. (See the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token-generate) for details) For every request to be authenticated, the token is passed as 'Authorization Bearer' header along with the request. ### Permissions and access roles Currently, an admin can see and manipulate all resources in a contract. A normal authenticated user can only see and manipulate resources he created. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed Services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as vLANs e.G. to shape the datacenter in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are readonly in the customer's VDC and can only be modified or deleted via the API. ### References + * *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster with pre-installed and managed Stackable operators. After the provision of these Stackable operators, the customer can interact with them directly and build his desired application on top of the Stackable platform. The Managed Stackable Data Platform by IONOS Cloud can be configured through the IONOS Cloud API in addition or as an alternative to the *Data Center Designer* (DCD). ## Getting Started To get your DataPlatformCluster up and running, the following steps needs to be performed. ### IONOS Cloud Account The first step is the creation of a IONOS Cloud account if not already existing. To register a **new account**, visit [cloud.ionos.com](https://cloud.ionos.com/compute/signup). ### Virtual Data Center (VDC) The Managed Stackable Data Platform needs a virtual data center (VDC) hosting the cluster. This could either be a VDC that already exists, especially if you want to connect the managed data platform to other services already running within your VDC. Otherwise, if you want to place the Managed Stackable Data Platform in a new VDC or you have not yet created a VDC, you need to do so. A new VDC can be created via the IONOS Cloud API, the IONOS Cloud CLI (`ionosctl`), or the DCD Web interface. For more information, see the [official documentation](https://docs.ionos.com/cloud/getting-started/basic-tutorials/data-center-basics). ### Get a authentication token To interact with this API a user specific authentication token is needed. This token can be generated using the IONOS Cloud CLI the following way: ``` ionosctl token generate ``` For more information, [see](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate). ### Create a new DataPlatformCluster Before using the Managed Stackable Data Platform, a new DataPlatformCluster must be created. To create a cluster, use the [Create DataPlatformCluster](paths./clusters.post) API endpoint. The provisioning of the cluster might take some time. To check the current provisioning status, you can query the cluster by calling the [Get Endpoint](#/DataPlatformCluster/getCluster) with the cluster ID that was presented to you in the response of the create cluster call. ### Add a DataPlatformNodePool To deploy and run a Stackable service, the cluster must have enough computational resources. The node pool that is provisioned along with the cluster is reserved for the Stackable operators. You may create further node pools with resources tailored to your use case. To create a new node pool use the [Create DataPlatformNodepool](paths./clusters/{clusterId}/nodepools.post) endpoint. ### Receive Kubeconfig Once the DataPlatformCluster is created, the kubeconfig can be accessed by the API. The kubeconfig allows the interaction with the provided cluster as with any regular Kubernetes cluster. To protect the deployment of the Stackable distribution, the kubeconfig does not provide you with administration rights for the cluster. What that means is that your actions and deployments are limited to the **default** namespace. If you still want to group your deployments, you have the option to create subnamespaces within the default namespace. This is made possible by the concept of *hierarchical namespaces* (HNS). You can find more details [here](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/). The kubeconfig can be downloaded with the [Get Kubeconfig](paths./clusters/{clusterId}/kubeconfig.get) endpoint using the cluster ID of the created DataPlatformCluster. ### Create Stackable Services You can leverage the `kubeconfig.json` file to access the Managed Stackable Data Platform cluster and manage the deployment of [Stackable data apps](https://stackable.tech/en/platform/). With the Stackable operators, you can deploy the [data apps](https://docs.stackable.tech/home/stable/getting_started.html#_deploying_stackable_services) you want in your Data Platform cluster. ## Authorization All endpoints are secured, so only an authenticated user can access them. As Authentication mechanism the default IONOS Cloud authentication mechanism is used. A detailed description can be found [here](https://api.ionos.com/docs/authentication/). ### Basic Auth The basic auth scheme uses the IONOS Cloud user credentials in form of a *Basic Authentication* header accordingly to [RFC 7617](https://datatracker.ietf.org/doc/html/rfc7617). ### API Key as Bearer Token The Bearer auth token used at the API Gateway is a user-related token created with the IONOS Cloud CLI (For details, see the [documentation](https://docs.ionos.com/cli-ionosctl/subcommands/authentication/token/generate)). For every request to be authenticated, the token is passed as *Authorization Bearer* header along with the request. ### Permissions and Access Roles Currently, an administrator can see and manipulate all resources in a contract. Furthermore, users with the group privilege `Manage Dataplatform` can access the API. ## Components The Managed Stackable Data Platform by IONOS Cloud consists of two components. The concept of a DataPlatformClusters and the backing DataPlatformNodePools the cluster is build on. ### DataPlatformCluster A DataPlatformCluster is the virtual instance of the customer services and operations running the managed services like Stackable operators. A DataPlatformCluster is a Kubernetes Cluster in the VDC of the customer. Therefore, it's possible to integrate the cluster with other resources as VLANs e.g. to shape the data center in the customer's need and integrate the cluster within the topology the customer wants to build. In addition to the Kubernetes cluster, a small node pool is provided which is exclusively used to run the Stackable operators. ### DataPlatformNodePool A DataPlatformNodePool represents the physical machines a DataPlatformCluster is build on top. All nodes within a node pool are identical in setup. The nodes of a pool are provisioned into virtual data centers at a location of your choice and you can freely specify the properties of all the nodes at once before creation. Nodes in node pools provisioned by the Managed Stackable Data Platform Cloud API are read-only in the customer's VDC and can only be modified or deleted via the API. ## References * - * API version: 0.0.7 + * API version: 1.1.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -12,7 +12,7 @@ package ionoscloud import ( "encoding/json" - "strings" + "reflect" "time" ) @@ -753,11 +753,6 @@ func (t *IonosTime) UnmarshalJSON(data []byte) error { if str[len(str)-1] == '"' { str = str[:len(str)-1] } - if !strings.Contains(str, "Z") { - /* forcefully adding timezone suffix to be able to parse the - * string using RFC3339 */ - str += "Z" - } tt, err := time.Parse(time.RFC3339, str) if err != nil { return err @@ -765,3 +760,17 @@ func (t *IonosTime) UnmarshalJSON(data []byte) error { *t = IonosTime{tt} return nil } + +// IsNil checks if an input is nil +func IsNil(i interface{}) bool { + if i == nil { + return true + } + switch reflect.TypeOf(i).Kind() { + case reflect.Chan, reflect.Func, reflect.Map, reflect.Ptr, reflect.UnsafePointer, reflect.Interface, reflect.Slice: + return reflect.ValueOf(i).IsNil() + case reflect.Array: + return reflect.ValueOf(i).IsZero() + } + return false +} diff --git a/vendor/modules.txt b/vendor/modules.txt index 52e53ce31..d27ec39a7 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -196,7 +196,7 @@ github.com/ionos-cloud/sdk-go-cert-manager # github.com/ionos-cloud/sdk-go-container-registry v1.1.0 ## explicit; go 1.18 github.com/ionos-cloud/sdk-go-container-registry -# github.com/ionos-cloud/sdk-go-dataplatform v1.0.0 +# github.com/ionos-cloud/sdk-go-dataplatform v1.0.3 ## explicit; go 1.18 github.com/ionos-cloud/sdk-go-dataplatform # github.com/ionos-cloud/sdk-go-dbaas-mariadb v1.0.0