DEV Community: Shivani Patel

AWS EKS CLUSTER

Shivani Patel — Thu, 17 Oct 2024 21:25:51 +0000

set up and deploy a scalable Kubernetes cluster on AWS using EKS, allowing for the efficient deployment of containerized applications.

1. Create a VPC Along with Subnet, Route Table, and Internet Gateway
Begin by creating a custom Virtual Private Cloud (VPC).
Set up subnets, route tables, and internet gateways for network traffic management within the VPC.

2. Create IAM Roles
Create two IAM roles:
One for the EKS cluster.
Another for EC2 nodes (worker nodes).

Create the EKS Cluster** Navigate to the EKS dashboard and create a cluster. Assign the name and role to the cluster, and AWS will provision it automatically. Under network settings, select private subnets and keep other settings at default. Once created, the EKS cluster will be running, and you can observe the creation of the two pods.

Create a Node Group** Create a node group for the cluster. Select the instance type (e.g., t2.micro) and configure the scaling parameters (e.g., desired size: 1, minimum size: 1, maximum size: 1). After successful creation, three worker pods will be available.

5. Install AWS CLI and Minikube
Download AWS CLI and Minikube.
Check their versions and configure AWS CLI using your access keys.
Update the EKS cluster and deploy the necessary configurations using deployment.yaml.
Verify that pods are running and the deployment is created (e.g., deployment-2048).

6. Manage Tags
Edit public subnets and add tags.
Assign an Elastic Load Balancer (ELB) role by adding relevant tags.
Copy the cluster URL for future use.

Configure IAM Identity Provider** Go to the IAM Identity Provider section in the AWS Management Console. Paste the cluster URL and set the audience to sts.amazon.com.

8. Create Policies Through JSON
Create a policy via a JSON file for the Load Balancer Controller.
Name the policy and modify the custom trust policy by adding the necessary account and role details.
Attach the generated ARN URL to the service YAML file and apply the ingress.yaml to complete the setup.

9. Set Up the Load Balancer
Once the load balancer is created, copy its DNS name.
Open a browser and paste the DNS name to confirm that your application (e.g., a sample 2048 game) has been successfully deployed.

AWS CODE PIPELINE

Shivani Patel — Mon, 14 Oct 2024 00:37:18 +0000

I implemented continuous integration for my Python application using AWS and GitHub. To begin, I created a GitHub repository for my code. Then, I set up an AWS CodePipeline to automate the integration, linking it to my GitHub repository and configuring AWS CodeBuild to handle the build process. I specified the necessary build environment and commands in CodeBuild. Once configured, I initiated the CI process by making updates to my GitHub code, which automatically triggered the pipeline, building and deploying the application as planned. This approach optimized my workflow by automating the steps from code updates to deployment, ensuring seamless and efficient integration and deployment.

Step 1: GitHub Repository Setup
Create a GitHub repository to store the source code for your Python application.(https://github.com/she0407/CI-CD-PIPELINE-DEMO)
Ensure that the repository is correctly configured with the necessary files for your project.

Step 2: AWS CodePipeline Creation
Create a new AWS CodePipeline to automate the CI process.
Connect the pipeline to the GitHub repository, specifying the repository and branch.

Step 3: AWS CodeBuild Setup
In the AWS CodeBuild service, create a new build project.
Under the Source Provider, log in to your GitHub account and choose the repository for the project.
In the Environment section, choose Ubuntu as the operating system and select the latest image version. Create a new service role if needed.
In the Buildspec section, switch to the editor mode and enter the commands for building your Python application.
Create the build project once everything is configured.

under the environment section I chose the os as ubuntu and cjhose the latest image version and created new service role.

under the buildspec I chose inster build commands and switch to editor and wrote commands for building

and I have created a code build.
afterwards I chose aws system manager and created three parameters to connect to my dockerhub one is url (docker.io) and username and passwords

Step 4: AWS Systems Manager Parameter Store Setup
Navigate to AWS Systems Manager and create three parameters to connect to Docker Hub:
Docker Hub URL (e.g., docker.io)
Docker Hub Username
Docker Hub Password
These parameters will be used later to push the Docker image to Docker Hub.
so I have successfully created a three parameters as shown below:

Step 5: IAM Role and Permissions
In IAM, create the necessary roles and permissions for your build process. You’ll need roles for CodeBuild and CodeDeploy, ensuring they have access to push images to Docker Hub and interact with EC2 instances.

Step 6: Build Execution
Return to AWS CodeBuild and click on Start Build. The build process will run according to the specified build commands.
Once the build is complete, the Docker image will be created and pushed to Docker Hub.

the image has been created in the Docker hub

Step 7: Pipeline Configuration
Set up the pipeline by defining the source, build, and deploy stages. For the source stage, select the GitHub repository and the branch to monitor.
Skip the deployment stage for now if it’s not required.

under the source stage I chose the latest git version and connected to github.

I chose the repo and the branch and format

and I have created pipeline skipping the deployment stage.

Step 8: EC2 Instance Setup for Deployment
In AWS EC2, launch a new instance for deployment. Ensure that the appropriate security groups are configured, and connect to the instance via SSH.
Verify that the CodeDeploy Agent is running.
as we can see under the build “build has succeeded ”
now I have created an application in the codedeploy then created application

I have gave the command to update and install the code deploy agent and checked if the instance has started or no

as the agent is under running status we can see from the below capture,

after that we create role to give the necessary information one I have created is for ec2 role full access and the code deploy role

Step 9: CodeDeploy Configuration
In AWS CodeDeploy, create a new application and deployment group.
Select the EC2 service role for CodeDeploy.
For deployment, select GitHub as the source and provide the repository token and commit ID for the latest version of the application.
Execute the deployment, which will pull the application code from GitHub and deploy it on the EC2 instance.

after that will move to dockerhub and copy the pull command and paste it into the startcontainer.sh file

and will commit and push it to github

will take the latest commit and then edit in the code deployment and now paste it ,

then all three build source and deployment stage individually succeed so will create a pipeline for that will add a stage to running pipeline and then add the build artifact as input artifact and run the pipeline ,

Step 11: Final Deployment and Pipeline Success
Use the latest commit and edit the CodeDeploy settings to deploy this updated version.
Verify that all three stages (source, build, and deployment) succeed, ensuring the complete CI pipeline runs smoothly.

and the whole pipeline is succeed as well .

AWS ELASTIC CONTAINER SERVICE

Shivani Patel — Sun, 13 Oct 2024 23:25:27 +0000

Virtualization : is like having multiple computers inside one physical computer. Each "virtual" computer (called a virtual machine or VM) acts like a separate, independent system with its own operating system and apps. It's great for keeping things separate and safe, but it can be a bit heavy and slow because each VM needs its own chunk of resources.

Containerization : on the other hand, is like having different apps in separate boxes, but all sharing the same space. Each box (called a container) holds everything an app needs to run, like the app itself and all its tools. It's lightweight and quick because all the containers share resources and don't need their own operating systems.
So, while virtualization divides up a computer into separate chunks, containerization apps neatly into separate boxes, making everything more efficient and easier to manage.
difference between containerization and virtualization

Docker🐋 : Think of Docker as a tool that helps you package and run your applications. It uses containers, which are like virtual boxes, to hold everything your app needs to run: the code, tools, libraries, and settings. Docker makes it easy to build these containers, move them around, and run them on any computer that has Docker installed. It's like a magic box that simplifies the process of getting your app up and running, no matter where you are or what kind of computer you're using.

Docker hub : Think of Docker Hub like a huge online store where people share their magic boxes (containers) with each other. It's a place where developers can find ready-made containers for all sorts of software, from databases to web servers.

container: A container is like a virtual box that holds an application and all the things it needs to work properly. It's a self-contained package that you can move around and run on any computer that has Docker installed.

Deploy image : Deploying an image in the context of Docker means taking a packaged application (which is called an image) and running it on a computer or a server. You've prepared your application along with all its necessary files, settings, and dependencies, and you've put them all neatly into a box called an image. Now, deploying that image is like taking that box to a location (like a computer or a server) and unpacking it so that your application can start running there.so, deploying an image simply means setting up and starting your application using the resources available on a computer or a server using Docker or a similar containerization platform.

So, Docker helps developers package their apps into containers, Docker Hub is a place to find and share these containers, and deploying an image is like putting your container to work.

Amazon ECS(Elastic Container Service): Amazon ECS is like a virtual playground where you can run and manage your software applications in containers. Think of each container as a small, self-contained package that holds everything your app needs to run smoothly. ECS helps you organize these containers so they work together seamlessly, making it easier to deploy, scale, and manage your applications in the cloud. It's like having a reliable playground manager that takes care of all the logistics while you focus on playing with your apps.

Launching AWS ECS CLUSTER :

Develop a task definition.
Specify details regarding the Docker image.
Incorporate the service into the Docker ECS cluster by updating the task definition file. here I have created a cluster with fargate

from the docker hub I have copied the image repository name which we need in the later step of task definition

Making a task plan with the nginxhello image means deciding how the nginxhello container will work within an ECS cluster. The nginxhello image probably has a basic NGINX web server that shows a simple 'Hello, World!' page. The task details cover stuff like what's in the Docker image, how much CPU and memory it needs, networking, and how the containers are defined.
here I have create dtask definition by putting the necessary information of the docker image

then we created a task to run in the cluster I've linked the security group to set up rules for traffic coming in and going out of the container. here I have choose the port http and the port range value is 80.

by using the public IP of the created task we can able to view the NGINX web server running on the web.as shown in the above screen capture.