- A computer with macOS, Windows, or Linux (8GB+ RAM, 10GB+ free disk space)
- Internet connection (stable broadband recommended)
- Credit card for AWS signup (Free Tier covers most, but AWS requires a card)
- Estimated time: 2-3 hours for complete tutorial
- Estimated cost: $0-5 USD (if you clean up resources promptly)
- No prior Kubernetes or AWS experience needed!
- Cloud: Computing services (servers, databases, storage) delivered over the internet (like AWS).
- Cluster: A group of computers (nodes) working together and managed as a si## 🎉 Congratulations & What You've Accomplished
You've successfully completed your first Kubernetes journey! Here's what you've achieved:
- Container Understanding: You now understand what containers are and why they're useful
- Kubernetes Fundamentals: You grasp the basic concepts of pods, deployments, and services
- Cloud Infrastructure: You've created and managed AWS cloud resources
- Command Line Proficiency: You've used kubectl to manage Kubernetes resources
- Troubleshooting: You know how to debug common issues
- Security Awareness: You understand basic security considerations
- EKS Cluster: A managed Kubernetes cluster on AWS
- Worker Nodes: EC2 instances running your applications
- Load Balancer: AWS application load balancer for internet access
- Nginx Application: A containerized web server with high availability
- Declarative Configuration: Using YAML files to define desired state
- Container Orchestration: Automatic management of application containers
- Service Discovery: How applications find and communicate with each other
- Scaling: Running multiple instances for reliability and performance
You're now ready to:
- Deploy your own applications to Kubernetes
- Explore more advanced Kubernetes features
- Build CI/CD pipelines
- Learn about microservices architecture
- Contribute to the Kubernetes community
Keep experimenting, keep learning, and welcome to the world of cloud-native computing!
Remember: The journey of a thousand microservices begins with a single container. 🐳e unit.
- Node: A single computer (virtual or physical) in your cluster that runs workloads.
- Pod: The smallest deployable unit in Kubernetes (usually contains one application container).
- Deployment: A blueprint that manages and updates multiple Pods automatically.
- Service: A stable network endpoint to access Pods (like a permanent address).
- kubeconfig: A configuration file that stores cluster connection info for
kubectland tools like OpenLens. - Container: A lightweight, portable package containing an application and all its dependencies.
- Image: A read-only template used to create containers (like a blueprint).
- YAML: A human-readable data format used to define Kubernetes resources.
- Introduction: What Are Containers & Kubernetes?
- Core Kubernetes Concepts (Simple Analogies)
- Getting Started with AWS
- Setting Up Your Local Machine (System Requirements & Tools)
- Essential kubectl Commands & Kubernetes Management
- Provisioning an EKS Cluster with eksctl
- Deploying Your First Application (Nginx) to EKS
- Exposing Your Application to the Internet
- Visualizing & Managing with OpenLens
- Enhanced Troubleshooting & Next Steps
- Security Best Practices & Production Considerations
- Cleaning Up AWS Resources (Avoid Charges)
Simple Analogy: Think of containers like shipping containers for software. Just as shipping containers standardize how goods are transported worldwide, software containers package an application with everything it needs to run (code, libraries, dependencies, configurations) into a single, portable unit.
Real-world example: Imagine you've written a web application on your laptop. It works perfectly, but when your colleague tries to run it on their computer, it fails because they have different versions of software installed. Containers solve this by packaging your app with the exact versions of everything it needs.
Key Benefits:
- Consistency: Runs the same everywhere (dev, testing, production)
- Portability: Move between cloud providers, laptops, servers
- Efficiency: Lightweight compared to virtual machines
- Isolation: Apps don't interfere with each other
The Problem: As your application grows successful, you might need:
- Multiple copies for high availability
- Automatic restarts when something crashes
- Load balancing between instances
- Rolling updates without downtime
- Scaling up during traffic spikes
Managing this manually becomes overwhelming quickly (imagine coordinating thousands of shipping containers by hand!).
Kubernetes Solution: An orchestration platform that automates all of this. It's like having a smart harbor master that:
- Decides which dock (node) each container should go to
- Monitors container health and replaces failed ones
- Distributes traffic evenly
- Scales up/down based on demand
Think of Kubernetes like a shipping company:
block-beta
columns 3
block:control["Control Plane (AWS Managed)"]:2
columns 2
apiServer["API Server"]
etcd[("etcd Database")]
scheduler["Scheduler"]
controller["Controller Manager"]
end
yourMachine["Your Machine<br/>kubectl + OpenLens"]
space:3
block:workers["Worker Nodes (EC2 Instances)"]:3
columns 3
node1["Node 1<br/>kubelet + kube-proxy"]
node2["Node 2<br/>kubelet + kube-proxy"]
nodeN["Node N<br/>kubelet + kube-proxy"]
pod1[("Pod")]
pod2[("Pod")]
pod3[("Pod")]
container1["Container"]
container2["Container"]
container3["Container"]
end
yourMachine --> apiServer
apiServer --> etcd
scheduler --> node1
controller --> node1
scheduler --> node2
controller --> node2
node1 --> pod1
node2 --> pod2
nodeN --> pod3
pod1 --> container1
pod2 --> container2
pod3 --> container3
classDef controlPlane fill:#e1f5fe,stroke:#01579b,stroke-width:2px
classDef worker fill:#f3e5f5,stroke:#4a148c,stroke-width:2px
classDef user fill:#e8f5e8,stroke:#1b5e20,stroke-width:2px
class control controlPlane
class workers worker
class yourMachine user
-
Control Plane (Master): The headquarters that makes decisions
- Plans where containers should be placed
- Monitors the health of the entire system
- Handles scheduling and scaling decisions
-
Worker Nodes: The actual docks/warehouses where work happens
- Run your application containers
- Report status back to the control plane
- Execute commands from the control plane
Why EKS (Elastic Kubernetes Service)?
- AWS manages the control plane for you (no setup/maintenance)
- Integrates seamlessly with other AWS services
- Automatic updates and patches
- High availability built-in
- Pod: The smallest deployable unit. Like a single shipping container.
- Deployment: A blueprint for running and updating Pods. Like a shipping schedule.
- Service: A stable way to access Pods. Like a port where containers are delivered.
- Namespace: Logical separation. Like different shipping companies using the same port.
- Node: A machine (VM or physical) that runs Pods. Like a dock at the port.
- Cluster: All the nodes and control plane together. Like the whole shipping yard.
graph TB
subgraph "Your Local Machine"
DEV[Developer Workstation]
TOOLS[kubectl + AWS CLI + eksctl + OpenLens]
end
subgraph "AWS Cloud"
subgraph "EKS Cluster"
subgraph "Control Plane (AWS Managed)"
API[API Server]
ETCD[(etcd)]
SCHED[Scheduler]
CTRL[Controller Manager]
end
subgraph "Worker Nodes (EC2)"
subgraph "Node 1"
NGINX1[Nginx Pod 1]
KUBELET1[kubelet]
end
subgraph "Node 2"
NGINX2[Nginx Pod 2]
KUBELET2[kubelet]
end
SVC[Nginx Service]
end
end
ALB[Application Load Balancer]
VPC[VPC with Subnets]
end
USERS[Internet Users]
%% Connections
DEV --> TOOLS
TOOLS --> API
API --> ETCD
API --> SCHED
API --> CTRL
SCHED --> KUBELET1
SCHED --> KUBELET2
SVC --> NGINX1
SVC --> NGINX2
ALB --> SVC
USERS --> ALB
%% Styling
classDef local fill:#e8f5e8,stroke:#2e7d32,stroke-width:2px
classDef aws fill:#fff3e0,stroke:#f57c00,stroke-width:2px
classDef control fill:#e3f2fd,stroke:#1565c0,stroke-width:2px
classDef worker fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px
classDef user fill:#ffebee,stroke:#c62828,stroke-width:2px
class DEV,TOOLS local
class ALB,VPC aws
class API,ETCD,SCHED,CTRL control
class NGINX1,NGINX2,KUBELET1,KUBELET2,SVC worker
class USERS user
flowchart TD
A[Start Setup Process] --> B[Install AWS CLI]
B --> C[Create AWS Account]
C --> D[Configure AWS Credentials]
D --> E[Install kubectl]
E --> F[Install eksctl]
F --> G[Install OpenLens]
G --> H[Verify All Tools]
H --> I[Setup Complete ✅]
%% Error paths
B -.-> B1[AWS CLI Installation Failed]
D -.-> D1[Credentials Configuration Failed]
E -.-> E1[kubectl Installation Failed]
F -.-> F1[eksctl Installation Failed]
G -.-> G1[OpenLens Installation Failed]
B1 --> B2[Check System Requirements]
D1 --> D2[Verify AWS Account & Permissions]
E1 --> E2[Check Kubernetes Version Compatibility]
F1 --> F2[Verify AWS CLI Configuration]
G1 --> G2[Check System Requirements]
B2 --> B
D2 --> D
E2 --> E
F2 --> F
G2 --> G
style A fill:#e1f5fe
style I fill:#e8f5e8
style B1 fill:#ffebee
style D1 fill:#ffebee
style E1 fill:#ffebee
style F1 fill:#ffebee
style G1 fill:#ffebee
- Go to aws.amazon.com and click Create an AWS Account.
- Follow the prompts (email, password, payment info—AWS Free Tier covers most beginner needs, but a credit card is required).
- Important: You may need to verify your identity and payment method.
- Many EKS resources are covered by the Free Tier, but ALWAYS clean up at the end to avoid charges.
- Set up AWS billing alerts for peace of mind.
- Create an IAM User:
- Go to the AWS Console → IAM → Users → Add user.
- Name:
eks-user, Access type: Programmatic access. - Attach policy:
AdministratorAccess(for learning; use least privilege in production). - Save the Access Key ID and Secret Access Key.
- Install AWS CLI:
- macOS:
brew install awscli - Windows: Download from AWS CLI Installer
- Linux:
- macOS:
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install- Verify install:
aws --version- Configure AWS CLI:
aws configureEnter your Access Key, Secret Key, region (e.g., us-east-1), and output format (json).
- macOS:
brew tap weaveworks/tap && brew install weaveworks/tap/eksctl - Windows:
choco install eksctl - Linux:
curl --silent --location "https://github.com/weaveworks/eksctl/releases/latest/download/eksctl_$(uname -s)_amd64.tar.gz" | tar xz -C /tmp
sudo mv /tmp/eksctl /usr/local/bin- Verify install:
eksctl version- RAM: At least 8GB recommended (for OpenLens and tools).
- Disk Space: 10GB+ free.
- OS: Windows, macOS, or Linux.
- Tools: AWS CLI, eksctl, kubectl, OpenLens.
- macOS:
brew install kubectl - Windows:
choco install kubernetes-cli - Linux:
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
chmod +x kubectl
sudo mv kubectl /usr/local/bin/- Verify install:
kubectl version --clientKubernetes is managed from the command line using kubectl. Here are the most useful commands for everyday tasks:
- Check cluster nodes:
kubectl get nodes
- List all pods:
kubectl get pods
- See pod details:
kubectl describe pod <pod-name>
- View pod logs:
kubectl logs <pod-name>
- Execute a shell in a pod:
kubectl exec -it <pod-name> -- /bin/sh
- List deployments:
kubectl get deployments
- Apply a YAML file:
kubectl apply -f <file.yaml>
- Delete a resource:
kubectl delete <resource-type> <name>
- Port-forward a service to your local machine:
kubectl port-forward service/<service-name> 8080:80
These commands help you inspect, troubleshoot, and manage your Kubernetes resources quickly and efficiently. For more, see the kubectl Cheat Sheet.
sequenceDiagram
participant User
participant eksctl
participant AWS_API
participant CloudFormation
participant EKS
participant EC2
participant VPC
User->>eksctl: eksctl create cluster
eksctl->>AWS_API: Authenticate with AWS
AWS_API-->>eksctl: Authentication successful
eksctl->>CloudFormation: Create cluster stack
CloudFormation->>VPC: Create VPC and subnets
VPC-->>CloudFormation: VPC created
CloudFormation->>EKS: Create EKS control plane
EKS-->>CloudFormation: Control plane creating...
CloudFormation->>EC2: Create worker node group
EC2-->>CloudFormation: Nodes launching...
Note over EKS: Control plane setup (5-10 min)
EKS-->>CloudFormation: Control plane ready
Note over EC2: Worker nodes joining cluster
EC2-->>CloudFormation: Nodes ready
CloudFormation-->>eksctl: Cluster creation complete
eksctl->>User: Update kubeconfig
eksctl-->>User: Cluster ready! ✅
User->>eksctl: kubectl get nodes
eksctl->>EKS: Query cluster
EKS-->>User: Show worker nodes
eksctl create cluster \
--name beginner-cluster \
--region us-east-1 \
--nodes 2 \
--node-type t3.small \
--with-oidc
# Optional: Add SSH access to nodes
# --ssh-access \
# --ssh-public-key <your-ssh-key>- --name: Name of your cluster.
- --region: AWS region (e.g.,
us-east-1). Not all regions support EKS—see EKS region availability. - --nodes: Number of worker nodes.
- --node-type: Instance type (t3.small is Free Tier eligible).
- --with-oidc: Enables IAM roles for service accounts.
- --ssh-access/--ssh-public-key: Optional, for SSH access to nodes. How to generate an SSH key.
Tip: Omit
--ssh-accessand--ssh-public-keyif you don't need SSH access.
- This can take 10–15 minutes. eksctl will update your kubeconfig automatically.
kubectl get nodesYou should see your EKS nodes listed.
flowchart TD
A[Create YAML Deployment File] --> B[Apply Deployment]
B --> C[Kubernetes API Server]
C --> D[Scheduler]
D --> E[Select Available Nodes]
E --> F[kubelet on Node]
F --> G[Pull Container Image]
G --> H[Create Pod]
H --> I[Start Container]
I --> J[Pod Running ✅]
%% Verification steps
J --> K[Verify Deployment]
K --> L[Check Pod Status]
L --> M[View Logs]
%% Error handling
G -.-> G1[Image Pull Failed]
H -.-> H1[Pod Creation Failed]
I -.-> I1[Container Start Failed]
G1 --> G2[Check Image Name/Registry]
H1 --> H2[Check Node Resources]
I1 --> I3[Check Container Config]
G2 --> G
H2 --> H
I3 --> I
style A fill:#e1f5fe
style J fill:#e8f5e8
style K fill:#fff3e0
style L fill:#fff3e0
style M fill:#fff3e0
style G1 fill:#ffebee
style H1 fill:#ffebee
style I1 fill:#ffebee
Create a file named nginx-deployment.yaml (use a text editor like VS Code, nano, or vim):
apiVersion: apps/v1
kind: Deployment
metadata:
name: nginx-deployment
spec:
replicas: 2
selector:
matchLabels:
app: nginx
template:
metadata:
labels:
app: nginx
spec:
containers:
- name: nginx
image: nginx:latest
ports:
- containerPort: 80Explanation:
- replicas: Number of Nginx Pods.
- image: Docker image to use.
- containerPort: Port exposed by the container.
kubectl apply -f nginx-deployment.yamlkubectl get podsWait until STATUS is Running. If not, check logs:
kubectl logs <pod-name>flowchart LR
User[Internet User] --> ALB[AWS Application Load Balancer]
ALB --> SVC[Kubernetes Service]
SVC --> POD1[Nginx Pod 1]
SVC --> POD2[Nginx Pod 2]
subgraph "AWS Cloud"
ALB
subgraph "EKS Cluster"
subgraph "Worker Node 1"
POD1
end
subgraph "Worker Node 2"
POD2
end
SVC
end
end
%% Traffic flow annotations
User -.->|HTTP Request| ALB
ALB -.->|Load Balances| SVC
SVC -.->|Routes to healthy pods| POD1
SVC -.->|Routes to healthy pods| POD2
POD1 -.->|HTTP Response| User
POD2 -.->|HTTP Response| User
style User fill:#e3f2fd
style ALB fill:#fff3e0
style SVC fill:#f3e5f5
style POD1 fill:#e8f5e8
style POD2 fill:#e8f5e8
Create a file named nginx-service.yaml:
apiVersion: v1
kind: Service
metadata:
name: nginx-service
spec:
type: LoadBalancer
selector:
app: nginx
ports:
- protocol: TCP
port: 80
targetPort: 80Explanation:
- type: LoadBalancer: Provisions an AWS load balancer.
- selector: Matches Pods with
app: nginx. - ports: Exposes port 80.
kubectl apply -f nginx-service.yamlkubectl get service nginx-serviceLook for the EXTERNAL-IP column. It may take a few minutes to appear. If it stays <pending>, check your AWS Console for issues (e.g., VPC/subnet setup).
Visit the URL in your browser to see the Nginx welcome page.
If you want to access your deployed application from your local machine (without waiting for a LoadBalancer or for testing), you can use kubectl port-forward. This command forwards a local port to a port on a Pod or Service in your cluster.
For example, to forward your local port 8080 to port 80 on the Nginx service:
kubectl port-forward service/nginx-service 8080:80Now, open your browser and go to http://localhost:8080 to view your app. Press Ctrl+C to stop forwarding.
- GUI for Kubernetes: Makes it easy to see and manage your cluster visually.
- macOS: Download from OpenLens Releases
- Windows: Same as above.
- Linux: AppImage or .deb/.rpm from the same page.
- Open OpenLens (it may prompt for permissions or updates on first launch).
- Click Add Cluster.
- Select your kubeconfig file (usually at
~/.kube/config). This file stores your cluster connection info. - Your EKS cluster should appear in the list.
- Dashboard: Overview of cluster health.
- Workloads: View Deployments, Pods, ReplicaSets.
- Networking: View Services, Ingresses.
- Logs: Click a Pod to see logs.
- Troubleshooting:
- Pending Pods: Check node capacity.
- Restart Deployments: Right-click → Restart.
flowchart TD
A[Application Not Working] --> B{Can you access kubectl?}
B -->|No| C[Check kubeconfig & AWS credentials]
B -->|Yes| D{Are pods running?}
C --> C1[aws sts get-caller-identity]
C1 --> C2[eksctl utils describe-stacks]
C2 --> D
D -->|No pods| E{Deployment exists?}
D -->|Pods pending| F[Check node resources]
D -->|Pods failing| G{What's the status?}
D -->|Pods running| H{Can you reach service?}
E -->|No| E1[Create deployment]
E -->|Yes| E2[Check deployment events]
E1 --> D
E2 --> D
F --> F1[kubectl top nodes]
F1 --> F2[Scale cluster or pods]
F2 --> D
G -->|ImagePullBackOff| G1[Check image name/registry]
G -->|CrashLoopBackOff| G2[Check pod logs]
G -->|Error| G3[kubectl describe pod]
G1 --> G4[Fix image reference]
G2 --> G5[Fix application config]
G3 --> G6[Address specific error]
G4 --> D
G5 --> D
G6 --> D
H -->|No| I{Service exists?}
H -->|Yes| J{LoadBalancer ready?}
I -->|No| I1[Create service]
I -->|Yes| I2[Check service endpoints]
I1 --> H
I2 --> H
J -->|Pending| J1[Wait or check AWS Console]
J -->|Error| J2[Check security groups & subnets]
J -->|Ready| K[Application accessible! ✅]
J1 --> J
J2 --> J
style A fill:#ffebee
style K fill:#e8f5e8
style C fill:#fff3e0
style F1 fill:#e3f2fd
style G2 fill:#e3f2fd
style I2 fill:#e3f2fd
ImagePullBackOff:
- Symptoms: Pod stuck in
ImagePullBackOffstatus - Causes & Solutions:
- Check image name/tag:
kubectl describe pod <pod-name> - Verify image exists: Try pulling manually with
docker pull <image-name> - Ensure internet access from nodes
- Check for private registry authentication issues
- Check image name/tag:
- Debug commands:
kubectl describe pod <pod-name> kubectl get events --field-selector involvedObject.name=<pod-name>
Pending Pods:
- Symptoms: Pod stuck in
Pendingstatus - Causes & Solutions:
- Insufficient cluster resources:
kubectl top nodes - Node selector constraints not met
- Persistent volume issues
- Insufficient cluster resources:
- Debug commands:
kubectl describe pod <pod-name> kubectl get nodes -o wide kubectl top nodes
CrashLoopBackOff:
- Symptoms: Pod continuously restarting
- Solutions:
- Check application logs:
kubectl logs <pod-name> --previous - Verify container configuration
- Check resource limits
- Check application logs:
- Debug commands:
kubectl logs <pod-name> --previous kubectl describe pod <pod-name>
Service Not Reachable:
- Load Balancer stuck in
<pending>:- Wait 5-10 minutes for AWS load balancer provisioning
- Check AWS Console → EC2 → Load Balancers
- Verify security groups allow traffic
- Check subnet configuration
- Debug commands:
kubectl get service <service-name> -o wide kubectl describe service <service-name> kubectl get endpoints <service-name>
DNS Resolution Issues:
- Test DNS from within cluster:
kubectl run test-pod --image=busybox -it --rm -- nslookup kubernetes.default
kubectl command fails:
- Check kubeconfig:
kubectl config current-context kubectl config get-contexts
- Verify AWS credentials:
aws sts get-caller-identity eksctl utils describe-stacks --region=us-east-1 --cluster=beginner-cluster
# Get all resources in cluster
kubectl get all --all-namespaces
# Get recent events
kubectl get events --sort-by='.metadata.creationTimestamp' | tail -20
# Check cluster health
kubectl get nodes -o wide
kubectl top nodes
# Debug specific pod
kubectl describe pod <pod-name>
kubectl logs <pod-name> --previous
kubectl exec -it <pod-name> -- /bin/bash
# Check service endpoints
kubectl get endpoints
# Monitor resources in real-time
kubectl get pods --watch# Check resource usage
kubectl top nodes
kubectl top pods
# Get detailed node information
kubectl describe node <node-name>
# Monitor cluster events
kubectl get events --watch-
Helm - Package manager for Kubernetes
# Install Helm brew install helm # Add popular chart repository helm repo add stable https://charts.helm.sh/stable helm repo update # Install apps with Helm helm install my-nginx stable/nginx-ingress
-
k9s - Terminal-based UI for Kubernetes
# Install k9s brew install k9s # Launch k9s k9s
-
Kubectl plugins
# Install krew (plugin manager) brew install krew # Install useful plugins kubectl krew install tree kubectl krew install ns
- Google GKE: Similar to EKS but on Google Cloud
- Azure AKS: Microsoft's managed Kubernetes service
- DigitalOcean Kubernetes: Simpler, cost-effective option
- Local Development: minikube, kind, or Docker Desktop
-
Deployments & Services
- Learn about different service types (ClusterIP, NodePort, LoadBalancer)
- Practice rolling updates and rollbacks
- Understand replica sets and scaling
-
Configuration Management
- ConfigMaps for application configuration
- Secrets for sensitive data
- Environment variables and volume mounts
-
Storage
- Persistent Volumes and Persistent Volume Claims
- Storage Classes
- StatefulSets for databases
-
Networking
- Ingress controllers and rules
- Network policies for security
- Service mesh (Istio, Linkerd)
-
Security
- RBAC (Role-Based Access Control)
- Pod Security Standards
- Network security policies
-
Monitoring & Logging
- Prometheus and Grafana for monitoring
- ELK or EFK stack for logging
- Jaeger for distributed tracing
-
CI/CD Integration
- GitOps with ArgoCD or Flux
- GitHub Actions or Jenkins pipelines
- Automated testing and deployment
-
Cluster Management
- Multi-cluster deployments
- Disaster recovery strategies
- Cost optimization
Free Resources:
Interactive Labs:
Books:
- "Kubernetes in Action" by Marko Lukša
- "Kubernetes Up & Running" by Kelsey Hightower
Certifications:
- Certified Kubernetes Administrator (CKA)
- Certified Kubernetes Application Developer (CKAD)
- Certified Kubernetes Security Specialist (CKS)
- Kubernetes Slack - Join #kubernetes-users
- AWS Containers Roadmap
- CNCF Community
- Stack Overflow - kubernetes tag
IMPORTANT: Always delete your EKS cluster and resources when done to avoid charges!
eksctl delete cluster --name beginner-cluster --region us-east-1This deletes the cluster and all associated AWS resources.
- Check the AWS Console (EKS, EC2, CloudFormation, EBS volumes, Elastic IPs) to ensure all resources are gone.
- Review your AWS billing dashboard to confirm no ongoing charges.
- EKS Control Plane: $0.10/hour (~$2.40 for 24 hours)
- t3.small EC2 instances (2 nodes):
$0.04/hour ($1.00 for 24 hours) - Application Load Balancer:
$0.025/hour ($0.60 for 24 hours) - Data transfer: Minimal for this tutorial
- Total estimated cost: $3-5 USD if you complete the tutorial and clean up within 24 hours
- EC2: 750 hours/month of t2.micro or t3.micro instances (first 12 months)
- EKS: Control plane charges apply (not covered by Free Tier)
- Data Transfer: 15GB outbound data transfer/month
- Delete resources immediately after completing the tutorial
- Use
t3.microinstances instead oft3.smallfor even lower costs - Set up billing alerts in AWS Console for $1, $5, and $10 thresholds
- Monitor costs in AWS Cost Explorer
⚠️ Important: EKS control plane costs ~$72/month if left running. Always clean up!
You’ve deployed your first Kubernetes app on AWS EKS and visualized it with OpenLens. Keep experimenting and learning!
Need more help?
Remember: Always clean up your resources to avoid unexpected AWS charges!
Before diving into AWS and Kubernetes, let's verify your local machine meets the requirements:
-
Check available RAM:
# macOS/Linux system_profiler SPHardwareDataType | grep "Memory:" # or free -h
-
Check available disk space:
df -h
-
Verify internet connection:
ping -c 4 google.com
Run these commands to verify if tools are already installed:
# Check if tools are installed
which aws && echo "✅ AWS CLI found" || echo "❌ AWS CLI not found"
which kubectl && echo "✅ kubectl found" || echo "❌ kubectl not found"
which eksctl && echo "✅ eksctl found" || echo "❌ eksctl not found"
# Check versions
aws --version 2>/dev/null || echo "AWS CLI not installed"
kubectl version --client 2>/dev/null || echo "kubectl not installed"
eksctl version 2>/dev/null || echo "eksctl not installed"If you're on macOS and don't have Homebrew installed:
# Install Homebrew (if not already installed)
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
# Verify Homebrew installation
brew --version