Amazon Elastic Kubernetes Service

Amazon EKS simplifies the deployment, management, and scaling of containerized applications using Kubernetes on AWS. It removes the complexities associated with setting up and running Kubernetes clusters, allowing developers and DevOps teams to focus more on application development and less on infrastructure management.

Key Features and Benefits

Managed Control Plane: EKS takes care of managing the Kubernetes control plane components, such as the API server, controller manager, etc. AWS handles upgrades, and patches, and ensures high availability of the control plane.

Automated Updates: EKS automatically updates the Kubernetes version, eliminating the need for manual intervention and ensuring that the cluster stays up-to-date with the latest features and security patches.

Scalability: EKS can automatically scale the Kubernetes control plane based on demand, ensuring the cluster remains responsive as the workload increases.

AWS Integration: EKS seamlessly integrates with various AWS services, such as AWS IAM for authentication and authorization, Amazon VPC for networking, and AWS Load Balancers for service exposure.

Security and Compliance: EKS is designed to meet various security standards and compliance requirements, providing a secure and compliant environment for running containerized workloads.

Monitoring and Logging: EKS integrates with AWS CloudWatch for monitoring cluster health and performance metrics, making it easier to track and troubleshoot issues.

Ecosystem and Community: Being a managed service, EKS benefits from continuous improvement, support, and contributions from the broader Kubernetes community.

❗️ Cons:

Cost: EKS is a managed service, and this convenience comes at a cost. Running an EKS cluster may be more expensive compared to self-managed Kubernetes, especially for large-scale deployments.

Less Control: While EKS provides a great deal of automation, it also means that you have less control over the underlying infrastructure and some Kubernetes configurations.

Self-Managed Kubernetes on EC2 Instances Pros:

Cost-Effective: Self-managed Kubernetes allows you to take advantage of EC2 spot instances and reserved instances, potentially reducing the overall cost of running Kubernetes clusters.

Flexibility: With self-managed Kubernetes, you have full control over the cluster's configuration and infrastructure, enabling customization and optimization for specific use cases.

EKS-Compatible: Self-managed Kubernetes on AWS can still leverage various AWS services and features, enabling integration with existing AWS resources.

Experimental Features: Self-managed Kubernetes allows you to experiment with the latest Kubernetes features and versions before they are officially supported by EKS.

❗️ Cons:

Complexity: Setting up and managing a self-managed Kubernetes cluster can be complex and time-consuming, especially for those new to Kubernetes or AWS.

Maintenance Overhead: Self-managed clusters require manual management of Kubernetes control plane updates, patches, and high availability.

Scaling Challenges: Scaling the control plane of a self-managed cluster can be challenging, and it requires careful planning to ensure high availability during scaling events.

Security and Compliance: Self-managed clusters may require additional effort to implement best practices for security and compliance compared to EKS, which comes with some built-in security features.

Lack of Automation: Self-managed Kubernetes require more manual intervention and scripting for certain operations, which can increase the risk of human error.

How to Create a K8S Cluster in AWS?

Creating a Kubernetes (K8S) cluster in AWS involves setting up an EKS cluster:

1. Define Cluster Configuration: Choose the AWS region, define the Kubernetes version, networking options (like VPC settings and subnets), and node group configuration (type of instances for worker nodes).

2. Create EKS Cluster: Using AWS Management Console, AWS CLI, or CloudFormation templates, initiate the creation of the EKS cluster based on the defined configuration.

3. Configure Worker Nodes: After creating the cluster, configure the worker nodes either by using EC2 instances or AWS Fargate, ensuring they join the EKS cluster for workload execution.

4. Access and Manage the Cluster: Access the cluster using the generated kubeconfig file, which contains the necessary information to authenticate and interact with the Kubernetes cluster using kubectl.

The EKS control plane is the managed Kubernetes control plane provided by AWS. It comprises essential components responsible for managing and orchestrating the Kubernetes cluster. These components include:

• API Server: Acts as the entry point for all RESTful API requests to the Kubernetes cluster. It validates and processes these requests, interacting with the cluster's data through the etc key-value store.

• Scheduler: Responsible for assigning pods to worker nodes based on resource requirements, policies, and constraints defined in the cluster.

• Controller Manager: Maintains the cluster's state by running various controllers that handle node operations, replication, endpoints, and more.

AWS manages these control plane components, ensuring their high availability, scalability, and security. Users don't interact directly with these components but use them through the Kubernetes API.

EKS Nodes (Worker Nodes) Registered with the Control Plane

EKS nodes, or worker nodes, are EC2 instances or AWS Fargate pods that execute the containerized applications (pods) within the Kubernetes cluster. These nodes are registered with the EKS control plane and perform the following functions:

• Pod Execution: Worker nodes run pods, which are the smallest deployable units in Kubernetes. Each pod consists of one or more containers sharing resources and network space.

• Communication with Control Plane: Nodes establish communication with the control plane to receive instructions, such as pod scheduling and status updates.

• Node Components: Each node runs various Kubernetes components, including the kubelet (agent managing the node and communicating with the control plane) and container runtime (like Docker or container).

These nodes form the computational backbone of the EKS cluster, executing applications and handling the workload assigned by the control plane.

AWS Fargate Profiles

AWS Fargate is a serverless compute engine for containers that allows users to run containers without managing the underlying infrastructure. In the context of EKS, Fargate can be used as an alternative to traditional EC2 instances for running pods.

• Fargate Profiles: These define which pods should run on AWS Fargate and specify pod execution parameters like CPU and memory requirements. Fargate profiles are associated with namespaces or labels, determining which pods get launched on Fargate.

• Serverless Scaling: Fargate abstracts the underlying infrastructure, automatically scaling resources based on the workload demand without manual intervention. Users pay only for the resources consumed by the pods.

Fargate Profiles offers a way to leverage serverless computing within an EKS cluster, providing flexibility and ease of use in managing containerized workloads.