Cloudprovider hetzner

cluster-autoscaler/cloudprovider/builder/builder_all.go

@@ -28,6 +28,7 @@ import (
 	"k8s.io/autoscaler/cluster-autoscaler/cloudprovider/digitalocean"
 	"k8s.io/autoscaler/cluster-autoscaler/cloudprovider/exoscale"
 	"k8s.io/autoscaler/cluster-autoscaler/cloudprovider/gce"
+	"k8s.io/autoscaler/cluster-autoscaler/cloudprovider/hetzner"
 	"k8s.io/autoscaler/cluster-autoscaler/cloudprovider/huaweicloud"
 	"k8s.io/autoscaler/cluster-autoscaler/cloudprovider/magnum"
 	"k8s.io/autoscaler/cluster-autoscaler/cloudprovider/packet"
@@ -45,6 +46,7 @@ var AvailableCloudProviders = []string{
 	cloudprovider.DigitalOceanProviderName,
 	cloudprovider.ExoscaleProviderName,
 	cloudprovider.HuaweicloudProviderName,
+	cloudprovider.HetznerProviderName,
 	clusterapi.ProviderName,
 }
 
@@ -71,6 +73,8 @@ func buildCloudProvider(opts config.AutoscalingOptions, do cloudprovider.NodeGro
 		return magnum.BuildMagnum(opts, do, rl)
 	case cloudprovider.HuaweicloudProviderName:
 		return huaweicloud.BuildHuaweiCloud(opts, do, rl)
+	case cloudprovider.HetznerProviderName:
+		return hetzner.BuildHetzner(opts, do, rl)
 	case packet.ProviderName:
 		return packet.BuildPacket(opts, do, rl)
 	case clusterapi.ProviderName:

cluster-autoscaler/cloudprovider/builder/builder_hetzner.go

@@ -0,0 +1,42 @@
+// +build exoscale
+
+/*
+Copyright 2020 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package builder
+
+import (
+	"k8s.io/autoscaler/cluster-autoscaler/cloudprovider"
+	"k8s.io/autoscaler/cluster-autoscaler/cloudprovider/hetzner"
+	"k8s.io/autoscaler/cluster-autoscaler/config"
+)
+
+// AvailableCloudProviders supported by the Hetzner cloud provider builder.
+var AvailableCloudProviders = []string{
+	cloudprovider.HetznerProviderName,
+}
+
+// DefaultCloudProvider is Hetzner.
+const DefaultCloudProvider = cloudprovider.HetznerProviderName
+
+func buildCloudProvider(opts config.AutoscalingOptions, do cloudprovider.NodeGroupDiscoveryOptions, rl *cloudprovider.ResourceLimiter) cloudprovider.CloudProvider {
+	switch opts.CloudProviderName {
+	case cloudprovider.HetznerProviderName:
+		return hetzner.BuildHetzner(opts, do, rl)
+	}
+
+	return nil
+}

cluster-autoscaler/cloudprovider/cloud_provider.go

@@ -41,6 +41,8 @@ const (
 	ExoscaleProviderName = "exoscale"
 	// GceProviderName gets the provider name of gce
 	GceProviderName = "gce"
+	// HetznerProviderName gets the provider name of hetzner
+	HetznerProviderName = "hetzner"
 	// MagnumProviderName gets the provider name of magnum
 	MagnumProviderName = "magnum"
 	// KubemarkProviderName gets the provider name of kubemark

cluster-autoscaler/cloudprovider/hetzner/README.md

@@ -0,0 +1,42 @@
+# Cluster Autoscaler for Hetzner Cloud
+
+The cluster autoscaler for Hetzner Cloud scales worker nodes.
+
+# Configuration
+
+`HCLOUD_TOKEN` Required Hetzner Cloud token.
+`HCLOUD_CLOUD_INIT` Base64 encoded Cloud Init yaml with commands to join the cluster
+`HCLOUD_IMAGE` Defaults to `ubuntu-20.04`, @see https://docs.hetzner.cloud/#images
+
+Node groups must be defined with the `--nodes=<min-servers>:<max-servers>:<instance-type>:<region>:<name>` flag.
+Multiple flags will create multiple node pools. For example:
+```
+--nodes=1:10:CPX51:FSN1:pool1
+--nodes=1:10:CPX51:NBG1:pool2
+--nodes=1:10:CX41:NBG1:pool3
+```
+
+# Development
+
+Make sure you're inside the root path of the [autoscaler
+repository](https://github.com/kubernetes/autoscaler)
+
+1.) Build the `cluster-autoscaler` binary:
+
+
+```
+make build-in-docker
+```
+
+2.) Build the docker image:
+
+```
+docker build -t hetzner/cluster-autoscaler:dev .
+```
+
+
+3.) Push the docker image to Docker hub:
+
+```
+docker push hetzner/cluster-autoscaler:dev
+```

cluster-autoscaler/cloudprovider/hetzner/hetzner_cloud_provider.go

@@ -0,0 +1,236 @@
+/*
+Copyright 2019 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package hetzner
+
+import (
+	"fmt"
+	apiv1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+	"k8s.io/autoscaler/cluster-autoscaler/cloudprovider"
+	"k8s.io/autoscaler/cluster-autoscaler/config"
+	"k8s.io/autoscaler/cluster-autoscaler/utils/errors"
+	"k8s.io/klog/v2"
+	"regexp"
+	"strconv"
+	"strings"
+	"sync"
+)
+
+var _ cloudprovider.CloudProvider = (*HetznerCloudProvider)(nil)
+
+const (
+	// GPULabel is the label added to nodes with GPU resource.
+	GPULabel             = hcloudLabelNamespace + "/gpu-node"
+	providerIDPrefix     = "hetzner-autoscale://"
+	nodeGroupLabel       = hcloudLabelNamespace + "/node-group"
+	hcloudLabelNamespace = "k8s.hcloud"
+	drainingNodePoolId   = "draining-node-pool"
+)
+
+// HetznerCloudProvider implements CloudProvider interface.
+type HetznerCloudProvider struct {
+	manager         *hetznerManager
+	resourceLimiter *cloudprovider.ResourceLimiter
+}
+
+// Name returns name of the cloud provider.
+func (d *HetznerCloudProvider) Name() string {
+	return cloudprovider.HetznerProviderName
+}
+
+// NodeGroups returns all node groups configured for this cloud provider.
+func (d *HetznerCloudProvider) NodeGroups() []cloudprovider.NodeGroup {
+	groups := make([]cloudprovider.NodeGroup, 0)
+	for i := range d.manager.nodeGroups {
+		groups = append(groups, d.manager.nodeGroups[i])
+	}
+	return groups
+}
+
+// NodeGroupForNode returns the node group for the given node, nil if the node
+// should not be processed by cluster autoscaler, or non-nil error if such
+// occurred. Must be implemented.
+func (d *HetznerCloudProvider) NodeGroupForNode(node *apiv1.Node) (cloudprovider.NodeGroup, error) {
+	server, err := d.manager.serverForNode(node)
+	if err != nil {
+		return nil, fmt.Errorf("failed to check if server %s exists error: %v", node.Spec.ProviderID, err)
+	}
+
+	if server == nil {
+		klog.V(3).Infof("failed to find hcloud server for node %s", node.Name)
+		return nil, nil
+	}
+
+	groupId, exists := server.Labels[nodeGroupLabel]
+	if !exists {
+		klog.Warningf("server %s does not contain nodegroup label %s, draining node", node.Name, nodeGroupLabel)
+		return addDrainingNodeGroup(d.manager, node)
+	}
+
+	group, exists := d.manager.nodeGroups[groupId]
+	if !exists {
+		klog.Warningf("nodegroup %s not configured for server %s, draining node", groupId, node.Name)
+		return addDrainingNodeGroup(d.manager, node)
+	}
+
+	return group, nil
+}
+
+func addDrainingNodeGroup(manager *hetznerManager, node *apiv1.Node) (cloudprovider.NodeGroup, error) {
+	klog.Warningf("server %s within not configured node, creating temp group with target size 0", node.Name, nodeGroupLabel)
+	return manager.addNodeToDrainingPool(node)
+}
+
+// Pricing returns pricing model for this cloud provider or error if not
+// available. Implementation optional.
+func (d *HetznerCloudProvider) Pricing() (cloudprovider.PricingModel, errors.AutoscalerError) {
+	return nil, cloudprovider.ErrNotImplemented
+}
+
+// GetAvailableMachineTypes get all machine types that can be requested from
+// the cloud provider. Implementation optional.
+func (d *HetznerCloudProvider) GetAvailableMachineTypes() ([]string, error) {
+	serverTypes, err := d.manager.client.ServerType.All(d.manager.apiCallContext)
+	if err != nil {
+		return nil, err
+	}
+
+	types := make([]string, len(serverTypes))
+	for _, server := range serverTypes {
+		types = append(types, server.Name)
+	}
+
+	return types, nil
+}
+
+// NewNodeGroup builds a theoretical node group based on the node definition
+// provided. The node group is not automatically created on the cloud provider
+// side. The node group is not returned by NodeGroups() until it is created.
+// Implementation optional.
+func (d *HetznerCloudProvider) NewNodeGroup(
+	machineType string,
+	labels map[string]string,
+	systemLabels map[string]string,
+	taints []apiv1.Taint,
+	extraResources map[string]resource.Quantity,
+) (cloudprovider.NodeGroup, error) {
+	return nil, cloudprovider.ErrNotImplemented
+}
+
+// GetResourceLimiter returns struct containing limits (max, min) for
+// resources (cores, memory etc.).
+func (d *HetznerCloudProvider) GetResourceLimiter() (*cloudprovider.ResourceLimiter, error) {
+	return d.resourceLimiter, nil
+}
+
+// GPULabel returns the label added to nodes with GPU resource.
+func (d *HetznerCloudProvider) GPULabel() string {
+	return GPULabel
+}
+
+// GetAvailableGPUTypes return all available GPU types cloud provider supports.
+func (d *HetznerCloudProvider) GetAvailableGPUTypes() map[string]struct{} {
+	return nil
+}
+
+// Cleanup cleans up open resources before the cloud provider is destroyed,
+// i.e. go routines etc.
+func (d *HetznerCloudProvider) Cleanup() error {
+	return nil
+}
+
+// Refresh is called before every main loop and can be used to dynamically
+// update cloud provider state. In particular the list of node groups returned
+// by NodeGroups() can change as a result of CloudProvider.Refresh().
+func (d *HetznerCloudProvider) Refresh() error {
+	return nil
+}
+
+// BuildHetzner builds the Hetzner cloud provider.
+func BuildHetzner(_ config.AutoscalingOptions, do cloudprovider.NodeGroupDiscoveryOptions, rl *cloudprovider.ResourceLimiter) cloudprovider.CloudProvider {
+	manager, err := newManager()
+	if err != nil {
+		klog.Fatalf("Failed to create Hetzner manager: %v", err)
+	}
+
+	provider, err := newHetznerCloudProvider(manager, rl)
+	if err != nil {
+		klog.Fatalf("Failed to create Hetzner cloud provider: %v", err)
+	}
+
+	validNodePoolName := regexp.MustCompile(`^[a-z0-9A-Z]+[a-z0-9A-Z\-\.\_]*[a-z0-9A-Z]+$|^[a-z0-9A-Z]{1}$`)
+	clusterUpdateLock := sync.Mutex{}
+
+	for _, nodegroupSpec := range do.NodeGroupSpecs {
+		spec, err := createNodePoolSpec(nodegroupSpec)
+		if err != nil {
+			klog.Fatalf("Failed to parse pool spec `%s` provider: %v", nodegroupSpec, err)
+		}
+
+		validNodePoolName.MatchString(spec.name)
+		servers, err := manager.allServers(spec.name)
+		if err != nil {
+			klog.Fatalf("Failed to get servers for for node pool %s error: %v", nodegroupSpec, err)
+		}
+
+		manager.nodeGroups[spec.name] = &hetznerNodeGroup{
+			manager:            manager,
+			id:                 spec.name,
+			minSize:            spec.minSize,
+			maxSize:            spec.maxSize,
+			instanceType:       strings.ToLower(spec.instanceType),
+			region:             strings.ToLower(spec.region),
+			targetSize:         len(servers),
+			clusterUpdateMutex: &clusterUpdateLock,
+		}
+	}
+
+	return provider
+}
+
+func createNodePoolSpec(groupSpec string) (*hetznerNodeGroupSpec, error) {
+	tokens := strings.SplitN(groupSpec, ":", 5)
+	if len(tokens) != 5 {
+		return nil, fmt.Errorf("expected format `<min-servers>:<max-servers>:<machine-type>:<region>:<name>` got %s", groupSpec)
+	}
+
+	definition := hetznerNodeGroupSpec{
+		instanceType: tokens[2],
+		region:       tokens[3],
+		name:         tokens[4],
+	}
+	if size, err := strconv.Atoi(tokens[0]); err == nil {
+		definition.minSize = size
+	} else {
+		return nil, fmt.Errorf("failed to set min size: %s, expected integer", tokens[0])
+	}
+
+	if size, err := strconv.Atoi(tokens[1]); err == nil {
+		definition.maxSize = size
+	} else {
+		return nil, fmt.Errorf("failed to set max size: %s, expected integer", tokens[1])
+	}
+
+	return &definition, nil
+}
+
+func newHetznerCloudProvider(manager *hetznerManager, rl *cloudprovider.ResourceLimiter) (*HetznerCloudProvider, error) {
+	return &HetznerCloudProvider{
+		manager:         manager,
+		resourceLimiter: rl,
+	}, nil
+}