karpenter

package
v0.0.0-...-862afa6 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 28, 2023 License: Apache-2.0 Imports: 21 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	AppName   = "karpenter"
	Namespace = "karpenter"
	Version   = "0.25.0"
)

Variables

View Source 
var AdminCr = &rbacv1.ClusterRole{
	TypeMeta: kubeutil.TypeClusterRoleV1,
	ObjectMeta: metav1.ObjectMeta{
		Name: "karpenter-admin",
		Labels: appendCommonLabels(
			map[string]string{

				"rbac.authorization.k8s.io/aggregate-to-admin": "true",
			},
		),
	},
	Rules: []rbacv1.PolicyRule{
		{
			Verbs: []string{
				"get",
				"list",
				"watch",
				"create",
				"delete",
				"patch",
			},
			APIGroups: []string{"karpenter.sh"},
			Resources: []string{"provisioners", "provisioners/status"},
		},
		{
			Verbs: []string{
				"get",
				"list",
				"watch",
				"create",
				"delete",
				"patch",
			},
			APIGroups: []string{"karpenter.k8s.aws"},
			Resources: []string{"awsnodetemplates"},
		},
	},
}
View Source 
var CanUpdateWebhooks = &rbacv1.ClusterRole{
	TypeMeta: metav1.TypeMeta{
		Kind:       "ClusterRole",
		APIVersion: "rbac.authorization.k8s.io/v1",
	},
	ObjectMeta: metav1.ObjectMeta{
		Name:   "karpenter",
		Labels: commonLabels,
	},
	Rules: []rbacv1.PolicyRule{
		{
			Verbs: []string{
				"get",
				"list",
				"watch",
			},
			APIGroups: []string{"karpenter.k8s.aws"},
			Resources: []string{"awsnodetemplates"},
		},
		{
			Verbs:         []string{"update"},
			APIGroups:     []string{"admissionregistration.k8s.io"},
			Resources:     []string{"validatingwebhookconfigurations"},
			ResourceNames: []string{"validation.webhook.karpenter.k8s.aws"},
		},
		{
			Verbs:         []string{"update"},
			APIGroups:     []string{"admissionregistration.k8s.io"},
			Resources:     []string{"mutatingwebhookconfigurations"},
			ResourceNames: []string{"defaulting.webhook.karpenter.k8s.aws"},
		},
		{
			Verbs:     []string{"patch", "update"},
			APIGroups: []string{"karpenter.k8s.aws"},
			Resources: []string{"awsnodetemplates/status"},
		},
	},
}
View Source 
var CertSecret = &corev1.Secret{
	TypeMeta: metav1.TypeMeta{
		Kind:       "Secret",
		APIVersion: "v1",
	},
	ObjectMeta: metav1.ObjectMeta{
		Name:      "karpenter-cert",
		Namespace: "karpenter",
		Labels:    commonLabels,
	},
	Data: map[string][]uint8{},
}
View Source 
var ContainerPorts = []corev1.ContainerPort{
	{
		Name:          "http-metrics",
		ContainerPort: 8080,
		Protocol:      corev1.Protocol("TCP"),
	},
	{
		Name:          "http",
		ContainerPort: 8081,
		Protocol:      corev1.Protocol("TCP"),
	},
	{
		Name:          "https-webhook",
		ContainerPort: 8443,
		Protocol:      corev1.Protocol("TCP"),
	},
}
View Source 
var CoreCr = &rbacv1.ClusterRole{
	TypeMeta: kubeutil.TypeClusterRoleV1,
	ObjectMeta: metav1.ObjectMeta{
		Name:   "karpenter-core",
		Labels: commonLabels,
	},
	Rules: []rbacv1.PolicyRule{
		{
			APIGroups: []string{"karpenter.sh"},
			Resources: []string{
				"provisioners",
				"provisioners/status",
				"machines",
				"machines/status",
			},
			Verbs: []string{"get", "list", "watch"},
		},
		{
			APIGroups: []string{""},
			Resources: []string{
				"pods",
				"nodes",
				"persistentvolumes",
				"persistentvolumeclaims",
				"replicationcontrollers",
				"namespaces",
			},
			Verbs: []string{"get", "list", "watch"},
		},
		{
			APIGroups: []string{"storage.k8s.io"},
			Resources: []string{"storageclasses", "csinodes"},
			Verbs:     []string{"get", "watch", "list"},
		},
		{
			APIGroups: []string{"apps"},
			Resources: []string{
				"daemonsets",
				"deployments",
				"replicasets",
				"statefulsets",
			},
			Verbs: []string{"list", "watch"},
		},
		{
			APIGroups: []string{"admissionregistration.k8s.io"},
			Resources: []string{
				"validatingwebhookconfigurations",
				"mutatingwebhookconfigurations",
			},
			Verbs: []string{"get", "watch", "list"},
		},
		{
			APIGroups: []string{"policy"},
			Resources: []string{"poddisruptionbudgets"},
			Verbs:     []string{"get", "list", "watch"},
		},
		{
			APIGroups: []string{"karpenter.sh"},
			Resources: []string{
				"provisioners/status",
				"machines",
				"machines/status",
			},
			Verbs: []string{"create", "delete", "patch"},
		},
		{
			APIGroups: []string{""},
			Resources: []string{"events"},
			Verbs:     []string{"create", "patch"},
		},
		{
			APIGroups: []string{""},
			Resources: []string{"nodes"},
			Verbs:     []string{"create", "patch", "delete"},
		},
		{
			APIGroups: []string{""},
			Resources: []string{"pods/eviction"},
			Verbs:     []string{"create"},
		},
		{
			APIGroups: []string{"admissionregistration.k8s.io"},
			ResourceNames: []string{
				"validation.webhook.karpenter.sh",
				"validation.webhook.config.karpenter.sh",
			},
			Resources: []string{"validatingwebhookconfigurations"},
			Verbs:     []string{"update"},
		},
		{
			APIGroups:     []string{"admissionregistration.k8s.io"},
			ResourceNames: []string{"defaulting.webhook.karpenter.sh"},
			Resources:     []string{"mutatingwebhookconfigurations"},
			Verbs:         []string{"update"},
		},
	},
}
View Source 
var Deploy = &appsv1.Deployment{
	TypeMeta: kubeutil.TypeDeploymentV1,
	ObjectMeta: metav1.ObjectMeta{
		Name:      "karpenter",
		Namespace: "karpenter",
		Labels:    commonLabels,
	},
	Spec: appsv1.DeploymentSpec{
		Replicas: P(int32(2)),
		Selector: &metav1.LabelSelector{
			MatchLabels: matchLabels,
		},
		Template: corev1.PodTemplateSpec{
			ObjectMeta: metav1.ObjectMeta{
				Labels: matchLabels,
			}, Spec: corev1.PodSpec{
				Containers: []corev1.Container{
					{
						Name:  "controller",
						Image: "public.ecr.aws/karpenter/controller:v" + Version,
						Ports: ContainerPorts,
						Env:   Environment,
						Resources: corev1.ResourceRequirements{
							Limits: corev1.ResourceList{
								corev1.ResourceName("cpu"):    resource.MustParse("1"),
								corev1.ResourceName("memory"): resource.MustParse("1Gi"),
							},
							Requests: corev1.ResourceList{
								corev1.ResourceName("cpu"):    resource.MustParse("1"),
								corev1.ResourceName("memory"): resource.MustParse("1Gi"),
							},
						},
						LivenessProbe: &corev1.Probe{
							ProbeHandler: corev1.ProbeHandler{
								HTTPGet: &corev1.HTTPGetAction{
									Path: "/healthz",
									Port: intstr.IntOrString{
										Type:   intstr.Type(1),
										StrVal: "http",
									},
								},
							}, InitialDelaySeconds: 30, TimeoutSeconds: 30,
						},
						ReadinessProbe: &corev1.Probe{
							ProbeHandler: corev1.ProbeHandler{
								HTTPGet: &corev1.HTTPGetAction{
									Path: "/readyz",
									Port: intstr.IntOrString{
										Type:   intstr.Type(1),
										StrVal: "http",
									},
								},
							}, TimeoutSeconds: 30,
						},
						ImagePullPolicy: corev1.PullPolicy("IfNotPresent"),
					},
				},
				DNSPolicy:          corev1.DNSPolicy("Default"),
				NodeSelector:       map[string]string{"kubernetes.io/os": "linux"},
				ServiceAccountName: "karpenter",
				SecurityContext:    &corev1.PodSecurityContext{FSGroup: P(int64(1000))},
				Affinity:           SetNodeAffinity,
				Tolerations: []corev1.Toleration{
					{
						Key:      "CriticalAddonsOnly",
						Operator: corev1.TolerationOperator("Exists"),
					},
				},
				PriorityClassName: "system-cluster-critical",
				TopologySpreadConstraints: []corev1.TopologySpreadConstraint{
					{
						MaxSkew:           1,
						TopologyKey:       "topology.kubernetes.io/zone",
						WhenUnsatisfiable: corev1.UnsatisfiableConstraintAction("ScheduleAnyway"),
						LabelSelector: &metav1.LabelSelector{
							MatchLabels: matchLabels,
						},
					},
				},
			},
		},
		Strategy:             appsv1.DeploymentStrategy{RollingUpdate: &appsv1.RollingUpdateDeployment{MaxUnavailable: &intstr.IntOrString{IntVal: 1}}},
		RevisionHistoryLimit: P(int32(10)),
	},
}
View Source 
var DnsRole = &rbacv1.Role{
	TypeMeta: kubeutil.TypeRoleV1,
	ObjectMeta: metav1.ObjectMeta{
		Name:      "karpenter-dns",
		Namespace: "kube-system",
		Labels:    commonLabels,
	},
	Rules: []rbacv1.PolicyRule{
		{
			Verbs:         []string{"get"},
			APIGroups:     []string{""},
			Resources:     []string{"services"},
			ResourceNames: []string{"kube-dns"},
		},
	},
}
View Source 
var DnsRoleBinding = &rbacv1.RoleBinding{
	TypeMeta: kubeutil.TypeRoleBindingV1,
	ObjectMeta: metav1.ObjectMeta{
		Name:      "karpenter-dns",
		Namespace: "kube-system",
		Labels:    commonLabels,
	},
	Subjects: kubeutil.RoleSubject("karpenter", "karpenter"),
	RoleRef:  kubeutil.RoleRef("karpenter-dns"),
}
View Source 
var Environment = []corev1.EnvVar{
	{
		Name:  "KUBERNETES_MIN_VERSION",
		Value: "1.19.0-0",
	},
	{
		Name:  "KARPENTER_SERVICE",
		Value: "karpenter",
	},
	{Name: "WEBHOOK_PORT", Value: "8443"},
	{Name: "METRICS_PORT", Value: "8080"},
	{
		Name:  "HEALTH_PROBE_PORT",
		Value: "8081",
	},
	{
		Name:      "SYSTEM_NAMESPACE",
		ValueFrom: &corev1.EnvVarSource{FieldRef: &corev1.ObjectFieldSelector{FieldPath: "metadata.namespace"}},
	},
	{
		Name: "MEMORY_LIMIT",
		ValueFrom: &corev1.EnvVarSource{
			ResourceFieldRef: &corev1.ResourceFieldSelector{
				ContainerName: "controller",
				Resource:      "limits.memory",
				Divisor:       resource.MustParse("0"),
			},
		},
	},
}
View Source 
var LoggingConfig = &corev1.ConfigMap{
	TypeMeta: kubeutil.TypeConfigMapV1,
	ObjectMeta: metav1.ObjectMeta{
		Name:      "config-logging",
		Namespace: "karpenter",
		Labels:    commonLabels,
	},
	Data: map[string]string{
		"loglevel.webhook":  "error",
		"zap-logger-config": ZapLoggerConfig,
	},
}
View Source 
var Pdb = &policyv1.PodDisruptionBudget{
	TypeMeta: metav1.TypeMeta{
		Kind:       "PodDisruptionBudget",
		APIVersion: "policy/v1",
	},
	ObjectMeta: metav1.ObjectMeta{Name: "karpenter", Namespace: "karpenter"},
	Spec: policyv1.PodDisruptionBudgetSpec{
		Selector: &metav1.LabelSelector{
			MatchLabels: map[string]string{
				"app.kubernetes.io/instance": "karpenter",
				"app.kubernetes.io/name":     "karpenter",
			},
		}, MaxUnavailable: &intstr.IntOrString{IntVal: 1},
	},
}
View Source 
var Role = &rbacv1.Role{
	TypeMeta: kubeutil.TypeRoleV1,
	ObjectMeta: metav1.ObjectMeta{
		Name:      "karpenter",
		Namespace: "karpenter",
		Labels:    commonLabels,
	},
	Rules: []rbacv1.PolicyRule{
		{
			Verbs:     []string{"get", "watch"},
			APIGroups: []string{"coordination.k8s.io"},
			Resources: []string{"leases"},
		},
		{
			Verbs:     []string{"get", "list", "watch"},
			APIGroups: []string{""},
			Resources: []string{"configmaps", "namespaces", "secrets"},
		},
		{
			Verbs:         []string{"update"},
			APIGroups:     []string{""},
			Resources:     []string{"secrets"},
			ResourceNames: []string{"karpenter-cert"},
		},
		{
			Verbs:     []string{"update", "patch", "delete"},
			APIGroups: []string{""},
			Resources: []string{"configmaps"},
			ResourceNames: []string{
				"karpenter-global-settings",
				"config-logging",
			},
		},
		{
			Verbs:     []string{"patch", "update"},
			APIGroups: []string{"coordination.k8s.io"},
			Resources: []string{"leases"},
			ResourceNames: []string{
				"karpenter-leader-election",
				"webhook.configmapwebhook.00-of-01",
				"webhook.defaultingwebhook.00-of-01",
				"webhook.validationwebhook.00-of-01",
				"webhook.webhookcertificates.00-of-01",
			},
		},
		{
			Verbs:     []string{"create"},
			APIGroups: []string{"coordination.k8s.io"},
			Resources: []string{"leases"},
		},
		{
			Verbs:     []string{"create"},
			APIGroups: []string{""},
			Resources: []string{"configmaps"},
		},
	},
}
View Source 
var S = terra.String
View Source 
var SetNodeAffinity = &corev1.Affinity{
	NodeAffinity: &corev1.NodeAffinity{
		RequiredDuringSchedulingIgnoredDuringExecution: &corev1.NodeSelector{
			NodeSelectorTerms: []corev1.NodeSelectorTerm{
				{
					MatchExpressions: []corev1.NodeSelectorRequirement{
						{
							Key:      "karpenter.sh/provisioner-name",
							Operator: corev1.NodeSelectorOperator("DoesNotExist"),
						},
					},
				},
			},
		},
	},
}
View Source 
var Svc = &corev1.Service{
	TypeMeta: kubeutil.TypeServiceV1,
	ObjectMeta: metav1.ObjectMeta{
		Name:      "karpenter",
		Namespace: "karpenter",
		Labels:    commonLabels,
	},
	Spec: corev1.ServiceSpec{
		Type:     corev1.ServiceType("ClusterIP"),
		Selector: matchLabels,
		Ports: []corev1.ServicePort{
			{
				Name:     "http-metrics",
				Protocol: corev1.ProtocolTCP,
				Port:     8080,
				TargetPort: intstr.IntOrString{
					Type:   intstr.Type(1),
					StrVal: "http-metrics",
				},
			},
			{
				Name:     "https-webhook",
				Protocol: corev1.ProtocolTCP,
				Port:     443,
				TargetPort: intstr.IntOrString{
					Type:   intstr.Type(1),
					StrVal: "https-webhook",
				},
			},
		},
	},
}
View Source 
var WebhookMutatingKarpenter = &ar.MutatingWebhookConfiguration{
	TypeMeta: kubeutil.TypeMutatingWebhookConfigurationV1,
	ObjectMeta: metav1.ObjectMeta{
		Name:   "defaulting.webhook.karpenter.sh",
		Labels: commonLabels,
	},
	Webhooks: []ar.MutatingWebhook{
		{
			Name:         "defaulting.webhook.karpenter.sh",
			ClientConfig: webHookClientConfig,
			Rules: []ar.RuleWithOperations{
				karpenterRuleWithNoDeleteOp,
			},
			FailurePolicy:           P(ar.Fail),
			SideEffects:             P(ar.SideEffectClassNone),
			AdmissionReviewVersions: []string{"v1"},
		},
	},
}
View Source 
var WebhookMutatingKarpenterAws = &ar.MutatingWebhookConfiguration{
	TypeMeta: kubeutil.TypeMutatingWebhookConfigurationV1,
	ObjectMeta: metav1.ObjectMeta{
		Name:   "defaulting.webhook.karpenter.k8s.aws",
		Labels: commonLabels,
	},
	Webhooks: []ar.MutatingWebhook{
		{
			Name:         "defaulting.webhook.karpenter.k8s.aws",
			ClientConfig: webHookClientConfig,
			Rules: []ar.RuleWithOperations{
				awsRuleWithNoDeleteOp,
				karpenterRuleWithNoDeleteOp,
			},
			FailurePolicy:           P(ar.Fail),
			SideEffects:             P(ar.SideEffectClassNone),
			AdmissionReviewVersions: []string{"v1"},
		},
	},
}
View Source 
var WebhookValidationKarpenter = &ar.ValidatingWebhookConfiguration{
	TypeMeta: kubeutil.TypeValidatingWebhookConfigurationV1,
	ObjectMeta: metav1.ObjectMeta{
		Name:   "validation.webhook.karpenter.sh",
		Labels: commonLabels,
	},
	Webhooks: []ar.ValidatingWebhook{
		{
			Name:         "validation.webhook.karpenter.sh",
			ClientConfig: webHookClientConfig,
			Rules: []ar.RuleWithOperations{
				{
					Operations: createUpdateOps,
					Rule:       provisionersRule,
				},
			},
			FailurePolicy:           P(ar.Fail),
			SideEffects:             P(ar.SideEffectClassNone),
			AdmissionReviewVersions: []string{"v1"},
		},
	},
}
View Source 
var WebhookValidationKarpenterAWS = &ar.ValidatingWebhookConfiguration{
	TypeMeta: metav1.TypeMeta{
		APIVersion: "admissionregistration.k8s.io/v1",
		Kind:       "ValidatingWebhookConfiguration",
	},
	ObjectMeta: metav1.ObjectMeta{
		Name:   "validation.webhook.karpenter.k8s.aws",
		Labels: commonLabels,
	},
	Webhooks: []ar.ValidatingWebhook{
		{
			AdmissionReviewVersions: []string{"v1"},
			ClientConfig: ar.WebhookClientConfig{
				Service: &ar.ServiceReference{
					Name:      "karpenter",
					Namespace: "karpenter",
				},
			},
			FailurePolicy: P(ar.FailurePolicyType("Fail")),
			Name:          "validation.webhook.karpenter.k8s.aws",
			Rules: []ar.RuleWithOperations{
				{
					Operations: []ar.OperationType{
						ar.OperationType("CREATE"),
						ar.OperationType("UPDATE"),
					},
					Rule: ar.Rule{
						APIGroups:   []string{"karpenter.k8s.aws"},
						APIVersions: []string{"v1alpha1"},
						Resources: []string{
							"awsnodetemplates",
							"awsnodetemplates/status",
						},
						Scope: P(ar.ScopeType("*")),
					},
				}, {
					Operations: []ar.OperationType{
						ar.OperationType("CREATE"),
						ar.OperationType("UPDATE"),
					},
					Rule: ar.Rule{
						APIGroups:   []string{"karpenter.sh"},
						APIVersions: []string{"v1alpha5"},
						Resources: []string{
							"provisioners",
							"provisioners/status",
						},
					},
				},
			},
			SideEffects: P(ar.SideEffectClass("None")),
		},
	},
}
View Source 
var WebhookValidationKarpenterConfig = &ar.ValidatingWebhookConfiguration{
	TypeMeta: kubeutil.TypeValidatingWebhookConfigurationV1,
	ObjectMeta: metav1.ObjectMeta{
		Name:   "validation.webhook.config.karpenter.sh",
		Labels: commonLabels,
	},
	Webhooks: []ar.ValidatingWebhook{
		{
			Name:                    "validation.webhook.config.karpenter.sh",
			ClientConfig:            webHookClientConfig,
			ObjectSelector:          &metav1.LabelSelector{MatchLabels: map[string]string{"app.kubernetes.io/part-of": "karpenter"}},
			FailurePolicy:           P(ar.Fail),
			SideEffects:             P(ar.SideEffectClassNone),
			AdmissionReviewVersions: []string{"v1"},
		},
	},
}
View Source 
var ZapLoggerConfig = `` /* 502-byte string literal not displayed */

Functions

func AWSAuthMapRoles 

func AWSAuthMapRoles(nodeRoleARN, fargateRoleARN string) []*awsauth.RolesAuth

func GlobalSettings 

func GlobalSettings(
	opts Opts,
) *corev1.ConfigMap

func P 

func P[T any](t T) *T

P returns a pointer to the given value.

Types

type Controller 

type Controller struct {
	NodeTerminationQueue
	IAMRole
}

Controller contains all the resources for the Karpenter controller. This includes the IAM role used to manage EC2 nodes (and more) via IRSA (IAM Roles for ServiceAccounts) and the SQS (Simple Queue Service) for being notified about nodes being terminated (typically spot instances).

type CustomResourceDefinitions 

type CustomResourceDefinitions struct {
	AWSNodeTemplates *apiextensionsv1.CustomResourceDefinition
	Provisioner      *apiextensionsv1.CustomResourceDefinition
}

type FargateProfile 

type FargateProfile struct {
	FargateProfile    *aws.EksFargateProfile         `validate:"required"`
	IAMRole           *aws.IamRole                   `validate:"required"`
	AssumeRole        *aws.DataIamPolicyDocument     `validate:"required"`
	PolicyAttachments []*aws.IamRolePolicyAttachment `validate:"required,dive,required"`
}

FargateProfile is the AWS EKS Fargate profile for the Karpenter pods to run on

type IAMRole 

type IAMRole struct {
	AssumeRolePolicy *aws.DataIamPolicyDocument `validate:"required"`
	Role             *aws.IamRole               `validate:"required"`
	RolePolicy       *aws.DataIamPolicyDocument `validate:"required"`
}

type Infra 

type Infra struct {
	FargateProfile
	InstanceProfile
	Controller
}

Infra is all the cloud resources for Karpenter to run on a pre-existing EKS cluster with an OIDC provider

func NewInfra 

func NewInfra(
	opts InfraOpts,
) Infra

type InfraOpts 

type InfraOpts struct {
	Name             string
	ClusterName      string
	ClusterARN       string
	PrivateSubnetIDs [3]string
	OIDCProviderArn  string
	OIDCProviderURL  string
}

type InstanceProfile 

type InstanceProfile struct {
	InstanceProfile   *aws.IamInstanceProfile        `validate:"required"`
	IAMRole           *aws.IamRole                   `validate:"required"`
	AssumeRole        *aws.DataIamPolicyDocument     `validate:"required"`
	PolicyAttachments []*aws.IamRolePolicyAttachment `validate:"required,dive,required"`
}

InstanceProfile is the AWS EC2 Instance Profile for the nodes provisioned by Karpenter to use.

type Karpenter 

type Karpenter struct {
	kube.App

	CustomResourceDefinitions

	Ns *corev1.Namespace
	// Configuration
	CertSecret *corev1.Secret
	Settings   *corev1.ConfigMap
	// LoggingConfig is not mounted but can be modified thanks to Role
	LoggingConfig *corev1.ConfigMap

	// Application
	Deploy *appsv1.Deployment
	Svc    *corev1.Service
	Pdb    *policyv1.PodDisruptionBudget

	// IAM
	SA *corev1.ServiceAccount

	DNSRole *rbacv1.Role
	DNSRb   *rbacv1.RoleBinding
	Role    *rbacv1.Role
	Rb      *rbacv1.RoleBinding

	// IAM cluster
	CR      *rbacv1.ClusterRole
	CRB     *rbacv1.ClusterRoleBinding
	CoreCR  *rbacv1.ClusterRole
	CoreCRB *rbacv1.ClusterRoleBinding
	AdminCR *rbacv1.ClusterRole

	// Webhooks
	WHValidation       *ar.ValidatingWebhookConfiguration
	WHValidationAWS    *ar.ValidatingWebhookConfiguration
	WHValidationConfig *ar.ValidatingWebhookConfiguration

	WHMutation    *ar.MutatingWebhookConfiguration
	WHMutationAWS *ar.MutatingWebhookConfiguration
}

func New 

func New(
	opts Opts,
) *Karpenter

type NodeTerminationQueue 

type NodeTerminationQueue struct {
	SimpleQueue         *aws.SqsQueue              `validate:"required"`
	QueuePolicy         *aws.SqsQueuePolicy        `validate:"required"`
	QueuePolicyDocument *aws.DataIamPolicyDocument `validate:"required"`
}

type Opts 

type Opts struct {
	ClusterName            string
	ClusterEndpoint        string
	IAMRoleArn             string
	DefaultInstanceProfile string
	InterruptQueue         string
}

type Provisioners 

type Provisioners struct {
	kube.App

	AWSNodeTemplate *v1alpha1.AWSNodeTemplate
	Default         *v1alpha5.Provisioner
}

func NewProvisioners 

func NewProvisioners(
	opts ProvisionersOpts,
) Provisioners

type ProvisionersOpts 

type ProvisionersOpts struct {
	ClusterName       string
	AvailabilityZones [3]string
}

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.