eksup 0.14.0

A CLI to aid in upgrading Amazon EKS clusters
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

use anyhow::Result;
use aws_sdk_autoscaling::types::AutoScalingGroup;
use aws_sdk_eks::types::{Addon, Cluster, FargateProfile, Nodegroup};
use k8s_openapi::api::core::v1::ConfigMap;

use crate::{
  eks::resources::{self as eks_resources, AddonVersion, ClusterInsight, LaunchTemplate, VpcSubnet},
  k8s::resources::{self as k8s_resources, ENIConfig, Node, StdPdb, StdResource},
};

/// Trait abstracting all AWS API operations used by eksup
pub trait AwsClients {
  fn get_cluster(&self, name: &str) -> impl std::future::Future<Output = Result<Cluster>> + Send;
  fn get_subnet_ips(&self, subnet_ids: Vec<String>)
  -> impl std::future::Future<Output = Result<Vec<VpcSubnet>>> + Send;
  fn get_addons(&self, cluster_name: &str) -> impl std::future::Future<Output = Result<Vec<Addon>>> + Send;
  fn get_addon_versions(
    &self,
    name: &str,
    kubernetes_version: &str,
  ) -> impl std::future::Future<Output = Result<AddonVersion>> + Send;
  fn get_eks_managed_nodegroups(
    &self,
    cluster_name: &str,
  ) -> impl std::future::Future<Output = Result<Vec<Nodegroup>>> + Send;
  fn get_self_managed_nodegroups(
    &self,
    cluster_name: &str,
  ) -> impl std::future::Future<Output = Result<Vec<AutoScalingGroup>>> + Send;
  fn get_fargate_profiles(
    &self,
    cluster_name: &str,
  ) -> impl std::future::Future<Output = Result<Vec<FargateProfile>>> + Send;
  fn get_launch_template(&self, id: &str) -> impl std::future::Future<Output = Result<LaunchTemplate>> + Send;
  fn get_service_quota_usage(
    &self,
    service_code: &str,
    quota_code: &str,
  ) -> impl std::future::Future<Output = Result<(String, f64, String)>> + Send;
  fn get_ec2_on_demand_vcpu_count(&self) -> impl std::future::Future<Output = Result<f64>> + Send;
  fn get_ebs_volume_storage(&self, volume_type: &str) -> impl std::future::Future<Output = Result<f64>> + Send;
  fn get_cluster_insights(
    &self,
    cluster_name: &str,
  ) -> impl std::future::Future<Output = Result<Vec<ClusterInsight>>> + Send;
}

/// Trait abstracting all Kubernetes API operations used by eksup
pub trait K8sClients {
  fn get_nodes(&self) -> impl std::future::Future<Output = Result<Vec<Node>>> + Send;
  fn get_configmap(
    &self,
    namespace: &str,
    name: &str,
  ) -> impl std::future::Future<Output = Result<Option<ConfigMap>>> + Send;
  fn get_eniconfigs(&self) -> impl std::future::Future<Output = Result<Vec<ENIConfig>>> + Send;
  fn get_resources(&self) -> impl std::future::Future<Output = Result<Vec<StdResource>>> + Send;
  fn get_pod_disruption_budgets(&self) -> impl std::future::Future<Output = Result<Vec<StdPdb>>> + Send;
}

/// Real AWS client implementation wrapping the SDK clients
pub struct RealAwsClients {
  eks: aws_sdk_eks::Client,
  ec2: aws_sdk_ec2::Client,
  asg: aws_sdk_autoscaling::Client,
  sq: aws_sdk_servicequotas::Client,
}

impl RealAwsClients {
  pub fn new(config: &aws_config::SdkConfig) -> Self {
    Self {
      eks: aws_sdk_eks::Client::new(config),
      ec2: aws_sdk_ec2::Client::new(config),
      asg: aws_sdk_autoscaling::Client::new(config),
      sq: aws_sdk_servicequotas::Client::new(config),
    }
  }
}

impl AwsClients for RealAwsClients {
  async fn get_cluster(&self, name: &str) -> Result<Cluster> {
    eks_resources::get_cluster(&self.eks, name).await
  }

  async fn get_subnet_ips(&self, subnet_ids: Vec<String>) -> Result<Vec<VpcSubnet>> {
    eks_resources::get_subnet_ips(&self.ec2, subnet_ids).await
  }

  async fn get_addons(&self, cluster_name: &str) -> Result<Vec<Addon>> {
    eks_resources::get_addons(&self.eks, cluster_name).await
  }

  async fn get_addon_versions(&self, name: &str, kubernetes_version: &str) -> Result<AddonVersion> {
    eks_resources::get_addon_versions(&self.eks, name, kubernetes_version).await
  }

  async fn get_eks_managed_nodegroups(&self, cluster_name: &str) -> Result<Vec<Nodegroup>> {
    eks_resources::get_eks_managed_nodegroups(&self.eks, cluster_name).await
  }

  async fn get_self_managed_nodegroups(&self, cluster_name: &str) -> Result<Vec<AutoScalingGroup>> {
    eks_resources::get_self_managed_nodegroups(&self.asg, cluster_name).await
  }

  async fn get_fargate_profiles(&self, cluster_name: &str) -> Result<Vec<FargateProfile>> {
    eks_resources::get_fargate_profiles(&self.eks, cluster_name).await
  }

  async fn get_launch_template(&self, id: &str) -> Result<LaunchTemplate> {
    eks_resources::get_launch_template(&self.ec2, id).await
  }

  async fn get_service_quota_usage(&self, service_code: &str, quota_code: &str) -> Result<(String, f64, String)> {
    eks_resources::get_service_quota(&self.sq, service_code, quota_code).await
  }

  async fn get_ec2_on_demand_vcpu_count(&self) -> Result<f64> {
    eks_resources::get_ec2_on_demand_vcpu_count(&self.ec2).await
  }

  async fn get_ebs_volume_storage(&self, volume_type: &str) -> Result<f64> {
    eks_resources::get_ebs_volume_storage(&self.ec2, volume_type).await
  }

  async fn get_cluster_insights(&self, cluster_name: &str) -> Result<Vec<ClusterInsight>> {
    eks_resources::get_cluster_insights(&self.eks, cluster_name).await
  }
}

/// Real Kubernetes client implementation wrapping kube-rs
pub struct RealK8sClients {
  client: kube::Client,
}

impl RealK8sClients {
  pub async fn new(cluster_name: &str) -> Result<Self> {
    match kube::Client::try_default().await {
      Ok(client) => Ok(Self { client }),
      Err(e) => {
        anyhow::bail!(
          "Unable to connect to cluster: {e}\n\n\
          Ensure kubeconfig file is present and updated to connect to the cluster.\n\
          Try: aws eks update-kubeconfig --name {cluster_name}"
        );
      }
    }
  }
}

impl K8sClients for RealK8sClients {
  async fn get_nodes(&self) -> Result<Vec<Node>> {
    k8s_resources::get_nodes(&self.client).await
  }

  async fn get_configmap(&self, namespace: &str, name: &str) -> Result<Option<ConfigMap>> {
    k8s_resources::get_configmap(&self.client, namespace, name).await
  }

  async fn get_eniconfigs(&self) -> Result<Vec<ENIConfig>> {
    k8s_resources::get_eniconfigs(&self.client).await
  }

  async fn get_resources(&self) -> Result<Vec<StdResource>> {
    k8s_resources::get_resources(&self.client).await
  }

  async fn get_pod_disruption_budgets(&self) -> Result<Vec<StdPdb>> {
    k8s_resources::get_pod_disruption_budgets(&self.client).await
  }
}