From a2316b49775d55948715a65f847fc68280caa12c Mon Sep 17 00:00:00 2001 From: cristi Date: Tue, 10 Dec 2024 15:43:58 +0200 Subject: [PATCH] feat: add dataplatform auto_scaling for nodepools --- .gitbook.yaml | 4 - CHANGELOG.md | 4 +- LICENSE | 373 ------------------ docs/data-sources/dataplatform_node_pool.md | 3 + docs/resources/dataplatform_node_pool.md | 7 +- go.mod | 2 +- go.sum | 2 + .../data_source_dataplatform_node_pool.go | 19 + ionoscloud/resource_dataplatform_nodepool.go | 22 ++ .../resource_dataplatform_nodepool_test.go | 14 + main.go | 2 +- services/dataplatform/nodepool.go | 79 +++- .../ionos-cloud/sdk-go-dataplatform/README.md | 189 ++++----- .../api_data_platform_cluster.go | 2 +- .../api_data_platform_meta_data.go | 2 +- .../api_data_platform_node_pool.go | 2 +- .../ionos-cloud/sdk-go-dataplatform/client.go | 6 +- .../sdk-go-dataplatform/configuration.go | 10 +- .../ionos-cloud/sdk-go-dataplatform/logger.go | 2 +- .../sdk-go-dataplatform/model_auto_scaling.go | 169 ++++++++ .../model_auto_scaling_base.go | 169 ++++++++ .../model_availability_zone.go | 2 +- .../sdk-go-dataplatform/model_cluster.go | 2 +- .../model_cluster_list_response_data.go | 2 +- .../model_cluster_response_data.go | 2 +- .../model_create_cluster_properties.go | 2 +- .../model_create_cluster_request.go | 2 +- .../model_create_node_pool_properties.go | 45 ++- .../model_create_node_pool_request.go | 2 +- .../model_error_message.go | 2 +- .../model_error_response.go | 2 +- .../sdk-go-dataplatform/model_lan.go | 2 +- .../model_maintenance_window.go | 2 +- .../sdk-go-dataplatform/model_metadata.go | 2 +- .../sdk-go-dataplatform/model_node_pool.go | 45 ++- .../model_node_pool_list_response_data.go | 2 +- .../model_node_pool_response_data.go | 2 +- .../model_patch_cluster_properties.go | 2 +- .../model_patch_cluster_request.go | 2 +- .../model_patch_node_pool_properties.go | 43 +- .../model_patch_node_pool_request.go | 2 +- .../sdk-go-dataplatform/model_route.go | 2 +- .../sdk-go-dataplatform/model_storage_type.go | 2 +- .../model_versions_get_200_response.go | 2 +- .../sdk-go-dataplatform/response.go | 2 +- .../ionos-cloud/sdk-go-dataplatform/utils.go | 2 +- vendor/modules.txt | 2 +- 47 files changed, 729 insertions(+), 532 deletions(-) delete mode 100644 .gitbook.yaml delete mode 100644 LICENSE create mode 100644 vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_auto_scaling.go create mode 100644 vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_auto_scaling_base.go diff --git a/.gitbook.yaml b/.gitbook.yaml deleted file mode 100644 index 9ad890316..000000000 --- a/.gitbook.yaml +++ /dev/null @@ -1,4 +0,0 @@ -root: gitbook_docs -structure: - readme: README.md - summary: summary.md diff --git a/CHANGELOG.md b/CHANGELOG.md index 84c741da1..ac6558108 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,4 +1,6 @@ -## 6.6.8 -- upcoming release +## 6.6.8 +### Features +- Add `auto_scaling` attribute to `ionoscloud_dataplatform_node_pool` resource. ### Fixes - Omitting the `location` attribute for some resources no longer generates an error diff --git a/LICENSE b/LICENSE deleted file mode 100644 index a612ad981..000000000 --- a/LICENSE +++ /dev/null @@ -1,373 +0,0 @@ -Mozilla Public License Version 2.0 -================================== - -1. Definitions --------------- - -1.1. "Contributor" - means each individual or legal entity that creates, contributes to - the creation of, or owns Covered Software. - -1.2. "Contributor Version" - means the combination of the Contributions of others (if any) used - by a Contributor and that particular Contributor's Contribution. - -1.3. "Contribution" - means Covered Software of a particular Contributor. - -1.4. "Covered Software" - means Source Code Form to which the initial Contributor has attached - the notice in Exhibit A, the Executable Form of such Source Code - Form, and Modifications of such Source Code Form, in each case - including portions thereof. - -1.5. "Incompatible With Secondary Licenses" - means - - (a) that the initial Contributor has attached the notice described - in Exhibit B to the Covered Software; or - - (b) that the Covered Software was made available under the terms of - version 1.1 or earlier of the License, but not also under the - terms of a Secondary License. - -1.6. "Executable Form" - means any form of the work other than Source Code Form. - -1.7. "Larger Work" - means a work that combines Covered Software with other material, in - a separate file or files, that is not Covered Software. - -1.8. "License" - means this document. - -1.9. "Licensable" - means having the right to grant, to the maximum extent possible, - whether at the time of the initial grant or subsequently, any and - all of the rights conveyed by this License. - -1.10. "Modifications" - means any of the following: - - (a) any file in Source Code Form that results from an addition to, - deletion from, or modification of the contents of Covered - Software; or - - (b) any new file in Source Code Form that contains any Covered - Software. - -1.11. "Patent Claims" of a Contributor - means any patent claim(s), including without limitation, method, - process, and apparatus claims, in any patent Licensable by such - Contributor that would be infringed, but for the grant of the - License, by the making, using, selling, offering for sale, having - made, import, or transfer of either its Contributions or its - Contributor Version. - -1.12. "Secondary License" - means either the GNU General Public License, Version 2.0, the GNU - Lesser General Public License, Version 2.1, the GNU Affero General - Public License, Version 3.0, or any later versions of those - licenses. - -1.13. "Source Code Form" - means the form of the work preferred for making modifications. - -1.14. "You" (or "Your") - means an individual or a legal entity exercising rights under this - License. For legal entities, "You" includes any entity that - controls, is controlled by, or is under common control with You. For - purposes of this definition, "control" means (a) the power, direct - or indirect, to cause the direction or management of such entity, - whether by contract or otherwise, or (b) ownership of more than - fifty percent (50%) of the outstanding shares or beneficial - ownership of such entity. - -2. License Grants and Conditions --------------------------------- - -2.1. Grants - -Each Contributor hereby grants You a world-wide, royalty-free, -non-exclusive license: - -(a) under intellectual property rights (other than patent or trademark) - Licensable by such Contributor to use, reproduce, make available, - modify, display, perform, distribute, and otherwise exploit its - Contributions, either on an unmodified basis, with Modifications, or - as part of a Larger Work; and - -(b) under Patent Claims of such Contributor to make, use, sell, offer - for sale, have made, import, and otherwise transfer either its - Contributions or its Contributor Version. - -2.2. Effective Date - -The licenses granted in Section 2.1 with respect to any Contribution -become effective for each Contribution on the date the Contributor first -distributes such Contribution. - -2.3. Limitations on Grant Scope - -The licenses granted in this Section 2 are the only rights granted under -this License. No additional rights or licenses will be implied from the -distribution or licensing of Covered Software under this License. -Notwithstanding Section 2.1(b) above, no patent license is granted by a -Contributor: - -(a) for any code that a Contributor has removed from Covered Software; - or - -(b) for infringements caused by: (i) Your and any other third party's - modifications of Covered Software, or (ii) the combination of its - Contributions with other software (except as part of its Contributor - Version); or - -(c) under Patent Claims infringed by Covered Software in the absence of - its Contributions. - -This License does not grant any rights in the trademarks, service marks, -or logos of any Contributor (except as may be necessary to comply with -the notice requirements in Section 3.4). - -2.4. Subsequent Licenses - -No Contributor makes additional grants as a result of Your choice to -distribute the Covered Software under a subsequent version of this -License (see Section 10.2) or under the terms of a Secondary License (if -permitted under the terms of Section 3.3). - -2.5. Representation - -Each Contributor represents that the Contributor believes its -Contributions are its original creation(s) or it has sufficient rights -to grant the rights to its Contributions conveyed by this License. - -2.6. Fair Use - -This License is not intended to limit any rights You have under -applicable copyright doctrines of fair use, fair dealing, or other -equivalents. - -2.7. Conditions - -Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted -in Section 2.1. - -3. Responsibilities -------------------- - -3.1. Distribution of Source Form - -All distribution of Covered Software in Source Code Form, including any -Modifications that You create or to which You contribute, must be under -the terms of this License. You must inform recipients that the Source -Code Form of the Covered Software is governed by the terms of this -License, and how they can obtain a copy of this License. You may not -attempt to alter or restrict the recipients' rights in the Source Code -Form. - -3.2. Distribution of Executable Form - -If You distribute Covered Software in Executable Form then: - -(a) such Covered Software must also be made available in Source Code - Form, as described in Section 3.1, and You must inform recipients of - the Executable Form how they can obtain a copy of such Source Code - Form by reasonable means in a timely manner, at a charge no more - than the cost of distribution to the recipient; and - -(b) You may distribute such Executable Form under the terms of this - License, or sublicense it under different terms, provided that the - license for the Executable Form does not attempt to limit or alter - the recipients' rights in the Source Code Form under this License. - -3.3. Distribution of a Larger Work - -You may create and distribute a Larger Work under terms of Your choice, -provided that You also comply with the requirements of this License for -the Covered Software. If the Larger Work is a combination of Covered -Software with a work governed by one or more Secondary Licenses, and the -Covered Software is not Incompatible With Secondary Licenses, this -License permits You to additionally distribute such Covered Software -under the terms of such Secondary License(s), so that the recipient of -the Larger Work may, at their option, further distribute the Covered -Software under the terms of either this License or such Secondary -License(s). - -3.4. Notices - -You may not remove or alter the substance of any license notices -(including copyright notices, patent notices, disclaimers of warranty, -or limitations of liability) contained within the Source Code Form of -the Covered Software, except that You may alter any license notices to -the extent required to remedy known factual inaccuracies. - -3.5. Application of Additional Terms - -You may choose to offer, and to charge a fee for, warranty, support, -indemnity or liability obligations to one or more recipients of Covered -Software. However, You may do so only on Your own behalf, and not on -behalf of any Contributor. You must make it absolutely clear that any -such warranty, support, indemnity, or liability obligation is offered by -You alone, and You hereby agree to indemnify every Contributor for any -liability incurred by such Contributor as a result of warranty, support, -indemnity or liability terms You offer. You may include additional -disclaimers of warranty and limitations of liability specific to any -jurisdiction. - -4. Inability to Comply Due to Statute or Regulation ---------------------------------------------------- - -If it is impossible for You to comply with any of the terms of this -License with respect to some or all of the Covered Software due to -statute, judicial order, or regulation then You must: (a) comply with -the terms of this License to the maximum extent possible; and (b) -describe the limitations and the code they affect. Such description must -be placed in a text file included with all distributions of the Covered -Software under this License. Except to the extent prohibited by statute -or regulation, such description must be sufficiently detailed for a -recipient of ordinary skill to be able to understand it. - -5. Termination --------------- - -5.1. The rights granted under this License will terminate automatically -if You fail to comply with any of its terms. However, if You become -compliant, then the rights granted under this License from a particular -Contributor are reinstated (a) provisionally, unless and until such -Contributor explicitly and finally terminates Your grants, and (b) on an -ongoing basis, if such Contributor fails to notify You of the -non-compliance by some reasonable means prior to 60 days after You have -come back into compliance. Moreover, Your grants from a particular -Contributor are reinstated on an ongoing basis if such Contributor -notifies You of the non-compliance by some reasonable means, this is the -first time You have received notice of non-compliance with this License -from such Contributor, and You become compliant prior to 30 days after -Your receipt of the notice. - -5.2. If You initiate litigation against any entity by asserting a patent -infringement claim (excluding declaratory judgment actions, -counter-claims, and cross-claims) alleging that a Contributor Version -directly or indirectly infringes any patent, then the rights granted to -You by any and all Contributors for the Covered Software under Section -2.1 of this License shall terminate. - -5.3. In the event of termination under Sections 5.1 or 5.2 above, all -end user license agreements (excluding distributors and resellers) which -have been validly granted by You or Your distributors under this License -prior to termination shall survive termination. - -************************************************************************ -* * -* 6. Disclaimer of Warranty * -* ------------------------- * -* * -* Covered Software is provided under this License on an "as is" * -* basis, without warranty of any kind, either expressed, implied, or * -* statutory, including, without limitation, warranties that the * -* Covered Software is free of defects, merchantable, fit for a * -* particular purpose or non-infringing. The entire risk as to the * -* quality and performance of the Covered Software is with You. * -* Should any Covered Software prove defective in any respect, You * -* (not any Contributor) assume the cost of any necessary servicing, * -* repair, or correction. This disclaimer of warranty constitutes an * -* essential part of this License. No use of any Covered Software is * -* authorized under this License except under this disclaimer. * -* * -************************************************************************ - -************************************************************************ -* * -* 7. Limitation of Liability * -* -------------------------- * -* * -* Under no circumstances and under no legal theory, whether tort * -* (including negligence), contract, or otherwise, shall any * -* Contributor, or anyone who distributes Covered Software as * -* permitted above, be liable to You for any direct, indirect, * -* special, incidental, or consequential damages of any character * -* including, without limitation, damages for lost profits, loss of * -* goodwill, work stoppage, computer failure or malfunction, or any * -* and all other commercial damages or losses, even if such party * -* shall have been informed of the possibility of such damages. This * -* limitation of liability shall not apply to liability for death or * -* personal injury resulting from such party's negligence to the * -* extent applicable law prohibits such limitation. Some * -* jurisdictions do not allow the exclusion or limitation of * -* incidental or consequential damages, so this exclusion and * -* limitation may not apply to You. * -* * -************************************************************************ - -8. Litigation -------------- - -Any litigation relating to this License may be brought only in the -courts of a jurisdiction where the defendant maintains its principal -place of business and such litigation shall be governed by laws of that -jurisdiction, without reference to its conflict-of-law provisions. -Nothing in this Section shall prevent a party's ability to bring -cross-claims or counter-claims. - -9. Miscellaneous ----------------- - -This License represents the complete agreement concerning the subject -matter hereof. If any provision of this License is held to be -unenforceable, such provision shall be reformed only to the extent -necessary to make it enforceable. Any law or regulation which provides -that the language of a contract shall be construed against the drafter -shall not be used to construe this License against a Contributor. - -10. Versions of the License ---------------------------- - -10.1. New Versions - -Mozilla Foundation is the license steward. Except as provided in Section -10.3, no one other than the license steward has the right to modify or -publish new versions of this License. Each version will be given a -distinguishing version number. - -10.2. Effect of New Versions - -You may distribute the Covered Software under the terms of the version -of the License under which You originally received the Covered Software, -or under the terms of any subsequent version published by the license -steward. - -10.3. Modified Versions - -If you create software not governed by this License, and you want to -create a new license for such software, you may create and use a -modified version of this License if you rename the license and remove -any references to the name of the license steward (except to note that -such modified license differs from this License). - -10.4. Distributing Source Code Form that is Incompatible With Secondary -Licenses - -If You choose to distribute Source Code Form that is Incompatible With -Secondary Licenses under the terms of this version of the License, the -notice described in Exhibit B of this License must be attached. - -Exhibit A - Source Code Form License Notice -------------------------------------------- - - This Source Code Form is subject to the terms of the Mozilla Public - License, v. 2.0. If a copy of the MPL was not distributed with this - file, You can obtain one at http://mozilla.org/MPL/2.0/. - -If it is not possible or desirable to put the notice in a particular -file, then You may include the notice in a location (such as a LICENSE -file in a relevant directory) where a recipient would be likely to look -for such a notice. - -You may add additional accurate notices of copyright ownership. - -Exhibit B - "Incompatible With Secondary Licenses" Notice ---------------------------------------------------------- - - This Source Code Form is "Incompatible With Secondary Licenses", as - defined by the Mozilla Public License, v. 2.0. diff --git a/docs/data-sources/dataplatform_node_pool.md b/docs/data-sources/dataplatform_node_pool.md index eae4d5747..cf1e93652 100644 --- a/docs/data-sources/dataplatform_node_pool.md +++ b/docs/data-sources/dataplatform_node_pool.md @@ -72,3 +72,6 @@ The following attributes are returned by the datasource: * `day_of_the_week` * `labels` - Key-value pairs attached to the node pool resource as [Kubernetes labels](https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/). * `annotations` - Key-value pairs attached to node pool resource as [Kubernetes annotations](https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/). +* `auto_scaling` - Whether the Node Pool should autoscale. For more details, please check the API documentation + - `min_node_count` - The minimum number of worker nodes the node pool can scale down to. Should be less than max_node_count + - `max_node_count` - The maximum number of worker nodes that the node pool can scale to. Should be greater than min_node_count diff --git a/docs/resources/dataplatform_node_pool.md b/docs/resources/dataplatform_node_pool.md index bb0aeea62..d3872e0a9 100644 --- a/docs/resources/dataplatform_node_pool.md +++ b/docs/resources/dataplatform_node_pool.md @@ -65,10 +65,13 @@ resource "ionoscloud_dataplatform_node_pool" "example" { * `storage_type` - (Optional)[int] The type of hardware for the volume. Must be set with one of the values `HDD` or `SSD`. The default value is `SSD`. * `storage_size` - (Optional)[int] The size of the volume in GB. The size must be greater than `10`GB. The default value is `20`. * `maintenance_window` - (Optional) 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`. + - `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`. * `labels` - (Optional)[map] Key-value pairs attached to the node pool resource as [Kubernetes labels](https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/). * `annotations` - (Optional)[map] Key-value pairs attached to node pool resource as [Kubernetes annotations](https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/). +* `auto_scaling` - (Optional)[string] Whether the Node Pool should autoscale. For more details, please check the API documentation + - `min_node_count` - (Optional)[int] The minimum number of worker nodes the node pool can scale down to. Should be less than max_node_count + - `max_node_count` - (Optional)[int] The maximum number of worker nodes that the node pool can scale to. Should be greater than min_node_count ## Import diff --git a/go.mod b/go.mod index fce888587..8055fe5ec 100644 --- a/go.mod +++ b/go.mod @@ -22,7 +22,7 @@ require ( github.com/ionos-cloud/sdk-go-bundle/shared v0.1.1 github.com/ionos-cloud/sdk-go-cert-manager v1.1.0 github.com/ionos-cloud/sdk-go-container-registry v1.2.0 - github.com/ionos-cloud/sdk-go-dataplatform v1.0.3 + github.com/ionos-cloud/sdk-go-dataplatform v1.1.1 github.com/ionos-cloud/sdk-go-dbaas-in-memory-db v1.0.1 github.com/ionos-cloud/sdk-go-dbaas-mariadb v1.1.1 github.com/ionos-cloud/sdk-go-dbaas-mongo v1.3.1 diff --git a/go.sum b/go.sum index 2f1e581de..a2286a3c8 100644 --- a/go.sum +++ b/go.sum @@ -128,6 +128,8 @@ github.com/ionos-cloud/sdk-go-container-registry v1.2.0 h1:C5r2XleKLbSFw9kmb4N8I github.com/ionos-cloud/sdk-go-container-registry v1.2.0/go.mod h1:woBP1+A4N0KXiRj9jG4y/hEXgrVjJv0CUlAvc24mCeo= 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-dataplatform v1.1.1 h1:Wu9TAiphRyMEweUcQlMblhVCl9qVxQlOYEOw+jJS+Ss= +github.com/ionos-cloud/sdk-go-dataplatform v1.1.1/go.mod h1:3rQrOZFbXcjK3C5Dnjzahsd9x7PO+b4AARdBwdz//Mg= github.com/ionos-cloud/sdk-go-dbaas-in-memory-db v1.0.1 h1:vd3SCqZ1OI5l7Tzql7NDb5Zlpna8e2SsfEYZRGHOkOo= github.com/ionos-cloud/sdk-go-dbaas-in-memory-db v1.0.1/go.mod h1:JLbyt5wj7+f/njy7pnWD6K+cCfe32p8VrjmKks055+w= github.com/ionos-cloud/sdk-go-dbaas-mariadb v1.1.1 h1:dZLxaH2n0nxCOKMkt49TibOiY1hkaHThpXEgJL0oZng= diff --git a/ionoscloud/data_source_dataplatform_node_pool.go b/ionoscloud/data_source_dataplatform_node_pool.go index 50018660a..40a608e31 100644 --- a/ionoscloud/data_source_dataplatform_node_pool.go +++ b/ionoscloud/data_source_dataplatform_node_pool.go @@ -113,6 +113,25 @@ func dataSourceDataplatformNodePool() *schema.Resource { Computed: true, Elem: &schema.Schema{Type: schema.TypeString}, }, + "auto_scaling": { + Type: schema.TypeList, + Description: "The range defining the minimum and maximum number of worker nodes that the managed node group can scale in", + Computed: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "min_node_count": { + Type: schema.TypeInt, + Description: "The minimum number of worker nodes the node pool can scale down to. Should be less than max_node_count", + Computed: true, + }, + "max_node_count": { + Type: schema.TypeInt, + Description: "The maximum number of worker nodes that the node pool can scale to. Should be greater than min_node_count", + Computed: true, + }, + }, + }, + }, "cluster_id": { Type: schema.TypeString, Required: true, diff --git a/ionoscloud/resource_dataplatform_nodepool.go b/ionoscloud/resource_dataplatform_nodepool.go index bd0151aff..91477b311 100644 --- a/ionoscloud/resource_dataplatform_nodepool.go +++ b/ionoscloud/resource_dataplatform_nodepool.go @@ -136,6 +136,28 @@ func resourceDataplatformNodePool() *schema.Resource { Description: "The UUID of an existing Dataplatform cluster.", ValidateDiagFunc: validation.ToDiagFunc(validation.IsUUID), }, + "auto_scaling": { + Type: schema.TypeList, + Description: "The range defining the minimum and maximum number of worker nodes that the managed node group can scale in", + Optional: true, + MaxItems: 1, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "min_node_count": { + Type: schema.TypeInt, + Description: "The minimum number of worker nodes the node pool can scale down to. Should be less than max_node_count", + Required: true, + ValidateDiagFunc: validation.ToDiagFunc(validation.IntAtLeast(1)), + }, + "max_node_count": { + Type: schema.TypeInt, + Description: "The maximum number of worker nodes that the node pool can scale to. Should be greater than min_node_count", + Required: true, + ValidateDiagFunc: validation.ToDiagFunc(validation.IntAtLeast(1)), + }, + }, + }, + }, }, Timeouts: &resourceDefaultTimeouts, } diff --git a/ionoscloud/resource_dataplatform_nodepool_test.go b/ionoscloud/resource_dataplatform_nodepool_test.go index 7a8ad83c9..6355ead8b 100644 --- a/ionoscloud/resource_dataplatform_nodepool_test.go +++ b/ionoscloud/resource_dataplatform_nodepool_test.go @@ -44,6 +44,8 @@ func TestAccDataplatformNodePoolBasic(t *testing.T) { resource.TestCheckResourceAttr(constant.DataplatformNodePoolResource+"."+constant.DataplatformNodePoolTestResource, "labels.color", "green"), resource.TestCheckResourceAttr(constant.DataplatformNodePoolResource+"."+constant.DataplatformNodePoolTestResource, "annotations.ann1", "value1"), resource.TestCheckResourceAttr(constant.DataplatformNodePoolResource+"."+constant.DataplatformNodePoolTestResource, "annotations.ann2", "value2"), + resource.TestCheckResourceAttr(constant.DataplatformNodePoolResource+"."+constant.DataplatformNodePoolTestResource, "auto_scaling.0.min_node_count", "1"), + resource.TestCheckResourceAttr(constant.DataplatformNodePoolResource+"."+constant.DataplatformNodePoolTestResource, "auto_scaling.0.max_node_count", "2"), ), }, { @@ -63,6 +65,8 @@ func TestAccDataplatformNodePoolBasic(t *testing.T) { resource.TestCheckResourceAttrPair(constant.DataSource+"."+constant.DataplatformNodePoolResource+"."+constant.DataplatformNodePoolTestDataSourceById, "labels.color", constant.DataplatformNodePoolResource+"."+constant.DataplatformNodePoolTestResource, "labels.color"), resource.TestCheckResourceAttrPair(constant.DataSource+"."+constant.DataplatformNodePoolResource+"."+constant.DataplatformNodePoolTestDataSourceById, "annotations.ann1", constant.DataplatformNodePoolResource+"."+constant.DataplatformNodePoolTestResource, "annotations.ann1"), resource.TestCheckResourceAttrPair(constant.DataSource+"."+constant.DataplatformNodePoolResource+"."+constant.DataplatformNodePoolTestDataSourceById, "annotations.ann2", constant.DataplatformNodePoolResource+"."+constant.DataplatformNodePoolTestResource, "annotations.ann2"), + resource.TestCheckResourceAttrPair(constant.DataSource+"."+constant.DataplatformNodePoolResource+"."+constant.DataplatformNodePoolTestDataSourceById, "auto_scaling.0.min_node_count", constant.DataplatformNodePoolResource+"."+constant.DataplatformNodePoolTestResource, "auto_scaling.0.min_node_count"), + resource.TestCheckResourceAttrPair(constant.DataSource+"."+constant.DataplatformNodePoolResource+"."+constant.DataplatformNodePoolTestDataSourceById, "auto_scaling.0.max_node_count", constant.DataplatformNodePoolResource+"."+constant.DataplatformNodePoolTestResource, "auto_scaling.0.max_node_count"), ), }, { @@ -152,6 +156,8 @@ func TestAccDataplatformNodePoolBasic(t *testing.T) { resource.TestCheckResourceAttr(constant.DataplatformNodePoolResource+"."+constant.DataplatformNodePoolTestResource, "maintenance_window.0.day_of_the_week", "Sunday"), resource.TestCheckResourceAttr(constant.DataplatformNodePoolResource+"."+constant.DataplatformNodePoolTestResource, "labels.foo", "bar"), resource.TestCheckResourceAttr(constant.DataplatformNodePoolResource+"."+constant.DataplatformNodePoolTestResource, "annotations.ann1", "value1"), + resource.TestCheckResourceAttr(constant.DataplatformNodePoolResource+"."+constant.DataplatformNodePoolTestResource, "auto_scaling.0.min_node_count", "1"), + resource.TestCheckResourceAttr(constant.DataplatformNodePoolResource+"."+constant.DataplatformNodePoolTestResource, "auto_scaling.0.max_node_count", "3"), ), }, }, @@ -266,6 +272,10 @@ resource ` + constant.DataplatformNodePoolResource + ` ` + constant.Dataplatform ann1 = "value1" ann2 = "value2" } + auto_scaling { + min_node_count = 1 + max_node_count = 2 + } } ` @@ -306,6 +316,10 @@ resource ` + constant.DataplatformNodePoolResource + ` ` + constant.Dataplatform annotations = { ann1 = "value1" } + auto_scaling { + min_node_count = 1 + max_node_count = 3 + } } ` diff --git a/main.go b/main.go index 6af42a6eb..26ea7019e 100644 --- a/main.go +++ b/main.go @@ -21,7 +21,7 @@ func main() { // set this to true to enable cli debugging your provider, by running headless and setting TF_REATTACH_PROVIDERS on the terraform terminal // this will enable you to debug when running plans from cli. - flag.BoolVar(&debugMode, "debuggable", false, "set to true to run the provider with support for debuggers like delve/goland") + flag.BoolVar(&debugMode, "debuggable", true, "set to true to run the provider with support for debuggers like delve/goland") flag.Parse() // log levels need to be shown correctly in terraform when enabling TF_LOG log.SetFlags(log.Flags() &^ (log.Ldate | log.Ltime)) diff --git a/services/dataplatform/nodepool.go b/services/dataplatform/nodepool.go index 18724de3e..4e28245f8 100644 --- a/services/dataplatform/nodepool.go +++ b/services/dataplatform/nodepool.go @@ -43,14 +43,20 @@ func (c *Client) ListNodePools(ctx context.Context, clusterId string) (dataplatf } func (c *Client) CreateNodePool(ctx context.Context, clusterId string, d *schema.ResourceData) (dataplatform.NodePoolResponseData, *dataplatform.APIResponse, error) { - dataplatformNodePool := GetDataplatformNodePoolDataCreate(d) + dataplatformNodePool, err := GetDataplatformNodePoolDataCreate(d) + if err != nil { + return dataplatform.NodePoolResponseData{}, nil, err + } 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) + dataplatformNodePool, err := GetDataplatformNodePoolDataUpdate(d) + if err != nil { + return dataplatform.NodePoolResponseData{}, nil, err + } clusterResponse, apiResponse, err := c.sdkClient.DataPlatformNodePoolApi.ClustersNodepoolsPatch(ctx, clusterId, nodePoolId).PatchNodePoolRequest(*dataplatformNodePool).Execute() apiResponse.LogInfo() return clusterResponse, apiResponse, err @@ -83,7 +89,7 @@ func (c *Client) IsNodePoolReady(ctx context.Context, d *schema.ResourceData) (b return strings.EqualFold(*subjectNodePool.Metadata.State, constant.Available), nil } -func GetDataplatformNodePoolDataCreate(d *schema.ResourceData) *dataplatform.CreateNodePoolRequest { +func GetDataplatformNodePoolDataCreate(d *schema.ResourceData) (*dataplatform.CreateNodePoolRequest, error) { dataplatformNodePool := dataplatform.CreateNodePoolRequest{ Properties: &dataplatform.CreateNodePoolProperties{}, @@ -149,10 +155,16 @@ func GetDataplatformNodePoolDataCreate(d *schema.ResourceData) *dataplatform.Cre dataplatformNodePool.Properties.Annotations = &annotations } - return &dataplatformNodePool + if autoscaling, err := getAutoscalingData(d); err != nil { + return &dataplatformNodePool, err + } else { + dataplatformNodePool.Properties.AutoScaling = autoscaling + } + + return &dataplatformNodePool, nil } -func GetDataplatformNodePoolDataUpdate(d *schema.ResourceData) *dataplatform.PatchNodePoolRequest { +func GetDataplatformNodePoolDataUpdate(d *schema.ResourceData) (*dataplatform.PatchNodePoolRequest, error) { dataplatformNodePool := dataplatform.PatchNodePoolRequest{ Properties: &dataplatform.PatchNodePoolProperties{}, @@ -183,7 +195,22 @@ func GetDataplatformNodePoolDataUpdate(d *schema.ResourceData) *dataplatform.Pat dataplatformNodePool.Properties.Annotations = &annotations } - return &dataplatformNodePool + if d.HasChange("auto_scaling.0.min_node_count") { + oldMinNodes, newMinNodes := d.GetChange("auto_scaling.0.min_node_count") + log.Printf("[INFO] dataplatform node pool autoscaling min # of nodes changed from %+v to %+v", oldMinNodes, newMinNodes) + } + + if d.HasChange("auto_scaling.0.max_node_count") { + oldMaxNodes, newMaxNodes := d.GetChange("auto_scaling.0.max_node_count") + log.Printf("[INFO] dataplatform node pool autoscaling max # of nodes changed from %+v to %+v", oldMaxNodes, newMaxNodes) + } + var autoscaling *dataplatform.AutoScaling + var err error + if autoscaling, err = getAutoscalingData(d); err != nil { + return &dataplatformNodePool, err + } + dataplatformNodePool.Properties.AutoScaling = autoscaling + return &dataplatformNodePool, nil } func SetDataplatformNodePoolData(d *schema.ResourceData, nodePool dataplatform.NodePoolResponseData) error { @@ -276,6 +303,19 @@ func SetDataplatformNodePoolData(d *schema.ResourceData, nodePool dataplatform.N return utils.GenerateSetError(nodePoolResourceName, "annotations", err) } } + + if nodePool.Properties.AutoScaling != nil && nodePool.Properties.AutoScaling.MinNodeCount != nil && + nodePool.Properties.AutoScaling.MaxNodeCount != nil && (*nodePool.Properties.AutoScaling.MinNodeCount != 0 && + *nodePool.Properties.AutoScaling.MaxNodeCount != 0) { + if err := d.Set("auto_scaling", []map[string]uint32{ + { + "min_node_count": uint32(*nodePool.Properties.AutoScaling.MinNodeCount), + "max_node_count": uint32(*nodePool.Properties.AutoScaling.MaxNodeCount), + }, + }); err != nil { + return err + } + } return nil } @@ -323,3 +363,30 @@ func SetNodePoolsData(d *schema.ResourceData, results []dataplatform.NodePoolRes } return nil } + +func getAutoscalingData(d *schema.ResourceData) (*dataplatform.AutoScaling, error) { + var autoscaling dataplatform.AutoScaling + + minNodeCount, asmnOk := d.GetOk("auto_scaling.0.min_node_count") + maxNodeCount, asmxnOk := d.GetOk("auto_scaling.0.max_node_count") + if !asmnOk && !asmxnOk { + return nil, nil + } + + asmnVal := int32(minNodeCount.(int)) + asmxnVal := int32(maxNodeCount.(int)) + if asmnVal == asmxnVal { + return &autoscaling, fmt.Errorf("error creating dataplatform node pool: max_node_count cannot be equal to min_node_count") + } + + if asmxnVal < asmnVal { + return &autoscaling, fmt.Errorf("error creating dataplatform node pool: max_node_count cannot be lower than min_node_count") + } + + log.Printf("[INFO] Setting Autoscaling minimum node count to : %d", asmnVal) + autoscaling.MinNodeCount = &asmnVal + log.Printf("[INFO] Setting Autoscaling maximum node count to : %d", asmxnVal) + autoscaling.MaxNodeCount = &asmxnVal + + return &autoscaling, nil +} 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 1a93f37f4..4b55c9cb3 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/README.md +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/README.md @@ -1,3 +1,5 @@ +[![Gitter](https://img.shields.io/gitter/room/ionos-cloud/sdk-general)](https://gitter.im/ionos-cloud/sdk-general) + # Go API client for ionoscloud *Managed Stackable Data Platform* by IONOS Cloud provides a preconfigured Kubernetes cluster @@ -140,8 +142,8 @@ and can only be modified or deleted via the API. ## 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: 1.1.0 -- Package version: 1.0.3 +- API version: 1.2.0 +- Package version: 1.1.1 - Build package: org.openapitools.codegen.languages.GoClientCodegen For more information, please visit [https://www.ionos.com](https://www.ionos.com) @@ -151,139 +153,108 @@ 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 +go get github.com/antihax/optional ``` Put the package under your project folder and add the following in import: ```golang -import ionoscloud "github.com/ionos-cloud/sdk-go-dataplatform" +import "./ionoscloud" ``` -To use a proxy, set the environment variable `HTTP_PROXY`: - -```golang -os.Setenv("HTTP_PROXY", "http://proxy_name:proxy_port") -``` +## Authentication -## Configuration of Server URL +All available server URLs are: -Default configuration comes with `Servers` field that contains server objects as defined in the OpenAPI specification. +- *https://api.ionos.com/dataplatform* - IONOS Cloud - Managed Stackable Data Platform API -### Select Server Configuration +By default, *https://api.ionos.com/dataplatform* is used, however this can be overriden at authentication, either +by setting the `IONOS_API_URL` environment variable or by specifying the `hostUrl` parameter when +initializing the sdk client. -For using other server than the one defined on index 0 set context value `sw.ContextServerIndex` of type `int`. +The username and password or the authentication token can be manually specified when initializing +the sdk client: ```golang -ctx := context.WithValue(context.Background(), ionoscloud.ContextServerIndex, 1) -``` - -### Templated Server URL -Templated server URL is formatted using default variables from configuration or from context value `sw.ContextServerVariables` of type `map[string]string`. +client := ionoscloud.NewAPIClient(ionoscloud.NewConfiguration(username, password, token, hostUrl)) -```golang -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. - -## Documentation for API Endpoints - -All URIs are relative to *https://api.ionos.com/dataplatform* - -Class | Method | HTTP request | Description ------------- | ------------- | ------------- | ------------- -*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 - +Environment variables can also be used. The sdk uses the following variables: +- IONOS_TOKEN - login via token. This is the recommended way to authenticate. +- IONOS_USERNAME - to specify the username used to login +- IONOS_PASSWORD - to specify the password +- IONOS_API_URL - to specify the API server URL -## Documentation For Models - - - [AvailabilityZone](docs/models/AvailabilityZone.md) - - [Cluster](docs/models/Cluster.md) - - [ClusterListResponseData](docs/models/ClusterListResponseData.md) - - [ClusterResponseData](docs/models/ClusterResponseData.md) - - [CreateClusterProperties](docs/models/CreateClusterProperties.md) - - [CreateClusterRequest](docs/models/CreateClusterRequest.md) - - [CreateNodePoolProperties](docs/models/CreateNodePoolProperties.md) - - [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) - - [NodePoolListResponseData](docs/models/NodePoolListResponseData.md) - - [NodePoolResponseData](docs/models/NodePoolResponseData.md) - - [PatchClusterProperties](docs/models/PatchClusterProperties.md) - - [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 - -- **Type**: HTTP Bearer token authentication - -Example +In this case, the client configuration needs to be initialized using `NewConfigurationFromEnv()`. ```golang -auth := context.WithValue(context.Background(), sw.ContextAccessToken, "BEARER_TOKEN_STRING") -r, err := client.Service.Operation(auth, args) -``` - -### basicAuth -- **Type**: HTTP basic authentication +client := ionoscloud.NewAPIClient(ionoscloud.NewConfigurationFromEnv()) -Example - -```golang -auth := context.WithValue(context.Background(), sw.ContextBasicAuth, sw.BasicAuth{ - UserName: "username", - Password: "password", -}) -r, err := client.Service.Operation(auth, args) ``` -## Documentation for Utility Methods - -Due to the fact that model structure members are all pointers, this package contains -a number of utility functions to easily obtain pointers to values of basic types. -Each of these functions takes a value of the given basic type and returns a pointer to it: - -* `PtrBool` -* `PtrInt` -* `PtrInt32` -* `PtrInt64` -* `PtrFloat` -* `PtrFloat32` -* `PtrFloat64` -* `PtrString` -* `PtrTime` - -## Author +## Documentation for API Endpoints +All URIs are relative to *https://api.ionos.com/dataplatform* +
+ API Endpoints table + + +| Class | Method | HTTP request | Description | +| ------------- | ------------- | ------------- | ------------- | +| 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 +All URIs are relative to *https://api.ionos.com/dataplatform* +
+API models list + + - [AutoScaling](docs/models/AutoScaling) + - [AutoScalingBase](docs/models/AutoScalingBase) + - [AvailabilityZone](docs/models/AvailabilityZone) + - [Cluster](docs/models/Cluster) + - [ClusterListResponseData](docs/models/ClusterListResponseData) + - [ClusterResponseData](docs/models/ClusterResponseData) + - [CreateClusterProperties](docs/models/CreateClusterProperties) + - [CreateClusterRequest](docs/models/CreateClusterRequest) + - [CreateNodePoolProperties](docs/models/CreateNodePoolProperties) + - [CreateNodePoolRequest](docs/models/CreateNodePoolRequest) + - [ErrorMessage](docs/models/ErrorMessage) + - [ErrorResponse](docs/models/ErrorResponse) + - [Lan](docs/models/Lan) + - [MaintenanceWindow](docs/models/MaintenanceWindow) + - [Metadata](docs/models/Metadata) + - [NodePool](docs/models/NodePool) + - [NodePoolListResponseData](docs/models/NodePoolListResponseData) + - [NodePoolResponseData](docs/models/NodePoolResponseData) + - [PatchClusterProperties](docs/models/PatchClusterProperties) + - [PatchClusterRequest](docs/models/PatchClusterRequest) + - [PatchNodePoolProperties](docs/models/PatchNodePoolProperties) + - [PatchNodePoolRequest](docs/models/PatchNodePoolRequest) + - [Route](docs/models/Route) + - [StorageType](docs/models/StorageType) + - [VersionsGet200Response](docs/models/VersionsGet200Response) + + +[[Back to API list]](#documentation-for-api-endpoints) [[Back to Model list]](#documentation-for-models) + +
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 992588864..60f92a3b4 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 @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. 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 f85523164..f0ad9441d 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 @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. 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 d02eb5d76..293d3a696 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 @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. 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 66e8966cd..ed9eba6e5 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/client.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/client.go @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.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.3" + Version = "1.1.1" ) -// APIClient manages communication with the IONOS Cloud - Managed Stackable Data Platform API API v1.1.0 +// APIClient manages communication with the IONOS Cloud - Managed Stackable Data Platform API API v1.2.0 // In most cases there should be only one, shared, APIClient. type APIClient struct { cfg *Configuration 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 da25cdc41..1eeed58b1 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/configuration.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/configuration.go @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -34,6 +34,12 @@ const ( defaultMaxWaitTime = time.Duration(2000) * time.Millisecond ) +var ( + IonosServerUrls = []string{ + "https://api.ionos.com/dataplatform", + } +) + // contextKeys are used to identify the type of value in the context. // Since these are string, it is possible to get a short description of the // context key for logging and debugging using key.String(). @@ -128,7 +134,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.3", + UserAgent: "ionos-cloud-sdk-go-dataplatform/v1.1.1", Debug: false, Username: username, Password: password, 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 b914a90fd..03f8bdb9c 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/logger.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/logger.go @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.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_auto_scaling.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_auto_scaling.go new file mode 100644 index 000000000..8cd0b730f --- /dev/null +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_auto_scaling.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.2.0 + */ + +// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. + +package ionoscloud + +import ( + "encoding/json" +) + +// AutoScaling struct for AutoScaling +type AutoScaling struct { + // The minimum number of nodes in a Node Pool + MinNodeCount *int32 `json:"minNodeCount"` + // The maximum number of nodes in a Node Pool + MaxNodeCount *int32 `json:"maxNodeCount"` +} + +// NewAutoScaling instantiates a new AutoScaling 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 NewAutoScaling(minNodeCount int32, maxNodeCount int32) *AutoScaling { + this := AutoScaling{} + + this.MinNodeCount = &minNodeCount + this.MaxNodeCount = &maxNodeCount + + return &this +} + +// NewAutoScalingWithDefaults instantiates a new AutoScaling 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 NewAutoScalingWithDefaults() *AutoScaling { + this := AutoScaling{} + return &this +} + +// GetMinNodeCount returns the MinNodeCount field value +// If the value is explicit nil, the zero value for int32 will be returned +func (o *AutoScaling) GetMinNodeCount() *int32 { + if o == nil { + return nil + } + + return o.MinNodeCount + +} + +// GetMinNodeCountOk returns a tuple with the MinNodeCount 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 *AutoScaling) GetMinNodeCountOk() (*int32, bool) { + if o == nil { + return nil, false + } + + return o.MinNodeCount, true +} + +// SetMinNodeCount sets field value +func (o *AutoScaling) SetMinNodeCount(v int32) { + + o.MinNodeCount = &v + +} + +// HasMinNodeCount returns a boolean if a field has been set. +func (o *AutoScaling) HasMinNodeCount() bool { + if o != nil && o.MinNodeCount != nil { + return true + } + + return false +} + +// GetMaxNodeCount returns the MaxNodeCount field value +// If the value is explicit nil, the zero value for int32 will be returned +func (o *AutoScaling) GetMaxNodeCount() *int32 { + if o == nil { + return nil + } + + return o.MaxNodeCount + +} + +// GetMaxNodeCountOk returns a tuple with the MaxNodeCount 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 *AutoScaling) GetMaxNodeCountOk() (*int32, bool) { + if o == nil { + return nil, false + } + + return o.MaxNodeCount, true +} + +// SetMaxNodeCount sets field value +func (o *AutoScaling) SetMaxNodeCount(v int32) { + + o.MaxNodeCount = &v + +} + +// HasMaxNodeCount returns a boolean if a field has been set. +func (o *AutoScaling) HasMaxNodeCount() bool { + if o != nil && o.MaxNodeCount != nil { + return true + } + + return false +} + +func (o AutoScaling) MarshalJSON() ([]byte, error) { + toSerialize := map[string]interface{}{} + if o.MinNodeCount != nil { + toSerialize["minNodeCount"] = o.MinNodeCount + } + + if o.MaxNodeCount != nil { + toSerialize["maxNodeCount"] = o.MaxNodeCount + } + + return json.Marshal(toSerialize) +} + +type NullableAutoScaling struct { + value *AutoScaling + isSet bool +} + +func (v NullableAutoScaling) Get() *AutoScaling { + return v.value +} + +func (v *NullableAutoScaling) Set(val *AutoScaling) { + v.value = val + v.isSet = true +} + +func (v NullableAutoScaling) IsSet() bool { + return v.isSet +} + +func (v *NullableAutoScaling) Unset() { + v.value = nil + v.isSet = false +} + +func NewNullableAutoScaling(val *AutoScaling) *NullableAutoScaling { + return &NullableAutoScaling{value: val, isSet: true} +} + +func (v NullableAutoScaling) MarshalJSON() ([]byte, error) { + return json.Marshal(v.value) +} + +func (v *NullableAutoScaling) 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_auto_scaling_base.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_auto_scaling_base.go new file mode 100644 index 000000000..df8f5b9bc --- /dev/null +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_auto_scaling_base.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.2.0 + */ + +// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. + +package ionoscloud + +import ( + "encoding/json" +) + +// AutoScalingBase Auto scaling configuration for the Node Pool +type AutoScalingBase struct { + // The minimum number of nodes in a Node Pool + MinNodeCount *int32 `json:"minNodeCount"` + // The maximum number of nodes in a Node Pool + MaxNodeCount *int32 `json:"maxNodeCount"` +} + +// NewAutoScalingBase instantiates a new AutoScalingBase 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 NewAutoScalingBase(minNodeCount int32, maxNodeCount int32) *AutoScalingBase { + this := AutoScalingBase{} + + this.MinNodeCount = &minNodeCount + this.MaxNodeCount = &maxNodeCount + + return &this +} + +// NewAutoScalingBaseWithDefaults instantiates a new AutoScalingBase 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 NewAutoScalingBaseWithDefaults() *AutoScalingBase { + this := AutoScalingBase{} + return &this +} + +// GetMinNodeCount returns the MinNodeCount field value +// If the value is explicit nil, the zero value for int32 will be returned +func (o *AutoScalingBase) GetMinNodeCount() *int32 { + if o == nil { + return nil + } + + return o.MinNodeCount + +} + +// GetMinNodeCountOk returns a tuple with the MinNodeCount 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 *AutoScalingBase) GetMinNodeCountOk() (*int32, bool) { + if o == nil { + return nil, false + } + + return o.MinNodeCount, true +} + +// SetMinNodeCount sets field value +func (o *AutoScalingBase) SetMinNodeCount(v int32) { + + o.MinNodeCount = &v + +} + +// HasMinNodeCount returns a boolean if a field has been set. +func (o *AutoScalingBase) HasMinNodeCount() bool { + if o != nil && o.MinNodeCount != nil { + return true + } + + return false +} + +// GetMaxNodeCount returns the MaxNodeCount field value +// If the value is explicit nil, the zero value for int32 will be returned +func (o *AutoScalingBase) GetMaxNodeCount() *int32 { + if o == nil { + return nil + } + + return o.MaxNodeCount + +} + +// GetMaxNodeCountOk returns a tuple with the MaxNodeCount 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 *AutoScalingBase) GetMaxNodeCountOk() (*int32, bool) { + if o == nil { + return nil, false + } + + return o.MaxNodeCount, true +} + +// SetMaxNodeCount sets field value +func (o *AutoScalingBase) SetMaxNodeCount(v int32) { + + o.MaxNodeCount = &v + +} + +// HasMaxNodeCount returns a boolean if a field has been set. +func (o *AutoScalingBase) HasMaxNodeCount() bool { + if o != nil && o.MaxNodeCount != nil { + return true + } + + return false +} + +func (o AutoScalingBase) MarshalJSON() ([]byte, error) { + toSerialize := map[string]interface{}{} + if o.MinNodeCount != nil { + toSerialize["minNodeCount"] = o.MinNodeCount + } + + if o.MaxNodeCount != nil { + toSerialize["maxNodeCount"] = o.MaxNodeCount + } + + return json.Marshal(toSerialize) +} + +type NullableAutoScalingBase struct { + value *AutoScalingBase + isSet bool +} + +func (v NullableAutoScalingBase) Get() *AutoScalingBase { + return v.value +} + +func (v *NullableAutoScalingBase) Set(val *AutoScalingBase) { + v.value = val + v.isSet = true +} + +func (v NullableAutoScalingBase) IsSet() bool { + return v.isSet +} + +func (v *NullableAutoScalingBase) Unset() { + v.value = nil + v.isSet = false +} + +func NewNullableAutoScalingBase(val *AutoScalingBase) *NullableAutoScalingBase { + return &NullableAutoScalingBase{value: val, isSet: true} +} + +func (v NullableAutoScalingBase) MarshalJSON() ([]byte, error) { + return json.Marshal(v.value) +} + +func (v *NullableAutoScalingBase) 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_availability_zone.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_availability_zone.go index 46a8179cc..cb70ac349 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 @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.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_cluster.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_cluster.go index d7a3f658e..1dc98b2b1 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 @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.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_cluster_list_response_data.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_cluster_list_response_data.go index a74e01611..7138cb761 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 @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.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_cluster_response_data.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_cluster_response_data.go index 887b04728..8b3cc06ea 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 @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.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_create_cluster_properties.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_create_cluster_properties.go index 2cc6a5d2d..2079bc2d7 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 @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.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_create_cluster_request.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_create_cluster_request.go index 7bd46e7fa..bffd308fd 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 @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.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_create_node_pool_properties.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_create_node_pool_properties.go index c79ac842c..e580fda8a 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 @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -35,6 +35,7 @@ type CreateNodePoolProperties struct { 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/). Annotations *map[string]interface{} `json:"annotations,omitempty"` + AutoScaling *AutoScaling `json:"autoScaling,omitempty"` } // NewCreateNodePoolProperties instantiates a new CreateNodePoolProperties object @@ -500,6 +501,44 @@ func (o *CreateNodePoolProperties) HasAnnotations() bool { return false } +// GetAutoScaling returns the AutoScaling field value +// If the value is explicit nil, the zero value for AutoScaling will be returned +func (o *CreateNodePoolProperties) GetAutoScaling() *AutoScaling { + if o == nil { + return nil + } + + return o.AutoScaling + +} + +// GetAutoScalingOk returns a tuple with the AutoScaling 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 *CreateNodePoolProperties) GetAutoScalingOk() (*AutoScaling, bool) { + if o == nil { + return nil, false + } + + return o.AutoScaling, true +} + +// SetAutoScaling sets field value +func (o *CreateNodePoolProperties) SetAutoScaling(v AutoScaling) { + + o.AutoScaling = &v + +} + +// HasAutoScaling returns a boolean if a field has been set. +func (o *CreateNodePoolProperties) HasAutoScaling() bool { + if o != nil && o.AutoScaling != nil { + return true + } + + return false +} + func (o CreateNodePoolProperties) MarshalJSON() ([]byte, error) { toSerialize := map[string]interface{}{} if o.Name != nil { @@ -546,6 +585,10 @@ func (o CreateNodePoolProperties) MarshalJSON() ([]byte, error) { toSerialize["annotations"] = o.Annotations } + if o.AutoScaling != nil { + toSerialize["autoScaling"] = o.AutoScaling + } + return json.Marshal(toSerialize) } 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 9d8b4525a..caf94744e 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 @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.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_error_message.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_error_message.go index 03305d7bd..8a5509b2a 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 @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.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_error_response.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_error_response.go index 2157c7422..6519ee01d 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 @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.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_lan.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_lan.go index f21dc9b68..74e510804 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_lan.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_lan.go @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.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_maintenance_window.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_maintenance_window.go index b5136d62c..13bc8cda5 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 @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.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_metadata.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_metadata.go index 2f4ef46fc..22501e87f 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 @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.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_node_pool.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_node_pool.go index d721365e4..0d722a201 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 @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -39,6 +39,7 @@ type NodePool struct { 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/). Annotations *map[string]interface{} `json:"annotations,omitempty"` + AutoScaling *AutoScaling `json:"autoScaling,omitempty"` } // NewNodePool instantiates a new NodePool object @@ -578,6 +579,44 @@ func (o *NodePool) HasAnnotations() bool { return false } +// GetAutoScaling returns the AutoScaling field value +// If the value is explicit nil, the zero value for AutoScaling will be returned +func (o *NodePool) GetAutoScaling() *AutoScaling { + if o == nil { + return nil + } + + return o.AutoScaling + +} + +// GetAutoScalingOk returns a tuple with the AutoScaling 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 *NodePool) GetAutoScalingOk() (*AutoScaling, bool) { + if o == nil { + return nil, false + } + + return o.AutoScaling, true +} + +// SetAutoScaling sets field value +func (o *NodePool) SetAutoScaling(v AutoScaling) { + + o.AutoScaling = &v + +} + +// HasAutoScaling returns a boolean if a field has been set. +func (o *NodePool) HasAutoScaling() bool { + if o != nil && o.AutoScaling != nil { + return true + } + + return false +} + func (o NodePool) MarshalJSON() ([]byte, error) { toSerialize := map[string]interface{}{} if o.Name != nil { @@ -632,6 +671,10 @@ func (o NodePool) MarshalJSON() ([]byte, error) { toSerialize["annotations"] = o.Annotations } + if o.AutoScaling != nil { + toSerialize["autoScaling"] = o.AutoScaling + } + return json.Marshal(toSerialize) } 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 4184c7ad7..5e069d9d4 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 @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.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_node_pool_response_data.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_node_pool_response_data.go index d2f2941dd..05d8273fa 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 @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.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_patch_cluster_properties.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_patch_cluster_properties.go index af198313f..5a48b20fe 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 @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.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_patch_cluster_request.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_patch_cluster_request.go index 27032b68b..388fbce69 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 @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.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_patch_node_pool_properties.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_patch_node_pool_properties.go index b25795268..df4f18291 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 @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. @@ -23,6 +23,7 @@ type PatchNodePoolProperties struct { 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/). Annotations *map[string]interface{} `json:"annotations,omitempty"` + AutoScaling *AutoScaling `json:"autoScaling,omitempty"` } // NewPatchNodePoolProperties instantiates a new PatchNodePoolProperties object @@ -195,6 +196,44 @@ func (o *PatchNodePoolProperties) HasAnnotations() bool { return false } +// GetAutoScaling returns the AutoScaling field value +// If the value is explicit nil, the zero value for AutoScaling will be returned +func (o *PatchNodePoolProperties) GetAutoScaling() *AutoScaling { + if o == nil { + return nil + } + + return o.AutoScaling + +} + +// GetAutoScalingOk returns a tuple with the AutoScaling 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 *PatchNodePoolProperties) GetAutoScalingOk() (*AutoScaling, bool) { + if o == nil { + return nil, false + } + + return o.AutoScaling, true +} + +// SetAutoScaling sets field value +func (o *PatchNodePoolProperties) SetAutoScaling(v AutoScaling) { + + o.AutoScaling = &v + +} + +// HasAutoScaling returns a boolean if a field has been set. +func (o *PatchNodePoolProperties) HasAutoScaling() bool { + if o != nil && o.AutoScaling != nil { + return true + } + + return false +} + func (o PatchNodePoolProperties) MarshalJSON() ([]byte, error) { toSerialize := map[string]interface{}{} if o.NodeCount != nil { @@ -213,6 +252,8 @@ func (o PatchNodePoolProperties) MarshalJSON() ([]byte, error) { toSerialize["annotations"] = o.Annotations } + toSerialize["autoScaling"] = o.AutoScaling + return json.Marshal(toSerialize) } 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 9fb1f7b1b..1b97eb2c7 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 @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.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 index e801b503e..9a0d0501a 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_route.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_route.go @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.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_storage_type.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_storage_type.go index 2735987df..a377f3dca 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 @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.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_versions_get_200_response.go b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/model_versions_get_200_response.go index d79b7d5cf..b6f9eeab0 100644 --- 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 @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. 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 a2de7c8d7..dd11fbbca 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/response.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/response.go @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.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 c2d2d2d2d..92d2d392b 100644 --- a/vendor/github.com/ionos-cloud/sdk-go-dataplatform/utils.go +++ b/vendor/github.com/ionos-cloud/sdk-go-dataplatform/utils.go @@ -3,7 +3,7 @@ * * *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 + * API version: 1.2.0 */ // Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT. diff --git a/vendor/modules.txt b/vendor/modules.txt index cf2c6c08f..99213b63a 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -328,7 +328,7 @@ github.com/ionos-cloud/sdk-go-cert-manager # github.com/ionos-cloud/sdk-go-container-registry v1.2.0 ## explicit; go 1.18 github.com/ionos-cloud/sdk-go-container-registry -# github.com/ionos-cloud/sdk-go-dataplatform v1.0.3 +# github.com/ionos-cloud/sdk-go-dataplatform v1.1.1 ## explicit; go 1.18 github.com/ionos-cloud/sdk-go-dataplatform # github.com/ionos-cloud/sdk-go-dbaas-in-memory-db v1.0.1