Kubernetes deployment within an ec2 instance

Kubernetes within an EC2 instance,

We have to follow these steps:-

1. Set up the EC2 instance with Kubernetes.
2. Create a Kubernetes Deployment YAML file.
3. Apply the deployment using kubectl.

Below is a guide and code to accomplish this.

Step 1: Set Up EC2 Instance with Kubernetes

1. Launch an EC2 Instance:

   • Choose an Amazon Linux 2 AMI or Ubuntu AMI.
   • Select an instance type (t2.micro is fine for small projects).
   • Configure security groups to allow SSH, HTTP, HTTPS, and any required Kubernetes ports.

2. Install Docker: SSH into your instance and install Docker.

   sudo yum update -y
   sudo amazon-linux-extras install docker -y
   sudo service docker start
   sudo usermod -aG docker ec2-user
   

   For Ubuntu:

   sudo apt-get update
   sudo apt-get install -y docker.io
   sudo systemctl start docker
   sudo usermod -aG docker ubuntu
   

3. Install Kubernetes (kubectl, kubeadm, kubelet):s

   sudo apt-get update && sudo apt-get install -y apt-transport-https curl
   curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
   echo "deb https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee -a /etc/apt/sources.list.d/kubernetes.list
   sudo apt-get update
   sudo apt-get install -y kubelet kubeadm kubectl
   sudo apt-mark hold kubelet kubeadm kubect

4. Initialize Kubernetes (Master Node):

   • This is usually done on the master node, but for simplicity, we'll assume a single-node setup.

   sudo kubeadm init --pod-network-cidr=192.168.0.0/16

5. Set up kubectl for your user:

   mkdir -p $HOME/.kube
   sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
   sudo chown $(id -u):$(id -g) $HOME/.kube/config
   

6. Install a Pod Network (Weave, Flannel, etc.):

   • For example, with Flannel:

   kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master

Step 2: Create a Kubernetes Deployment YAML File

Below is a sample YAML file for deploying a simple Nginx application.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: LoadBalancer

Step 3: Deploy the Application

1. Apply the Deployment: Save the above YAML content to a file named nginx-deployment.yaml.

   kubectl apply -f nginx-deployment.yaml

2. Verify the Deployment:

   kubectl get deployments
   kubectl get pods
   kubectl get services
   

3. Access the Application:

   • If you have set the Service type to LoadBalancer, Kubernetes will provision a public IP through your cloud provider. Use kubectl get services to find the external IP and access your application via a browser or curl.

Additional Considerations:

• Scaling: You can scale the number of replicas easily with:

  kubectl scale deployment nginx-deployment --replicas=5

• Monitoring: Consider setting up monitoring for your Kubernetes cluster using tools like Prometheus and Grafana.

This process will give you a basic setup to deploy an application on Kubernetes running on an EC2 instance. For production, you should explore multi-node clusters, proper security configurations, and advanced networking setups.