DEV Community: Swapnil Suresh Mohite

🚀 Just Launched — My Personal Cloud & DevOps Portfolio! 🌩️

Swapnil Suresh Mohite — Sun, 26 Oct 2025 18:14:13 +0000

After months of building, debugging, and fine-tuning…
I’ve finally created a space that reflects my DevOps journey, projects, and passion for automation ⚙️

🔗 Live Now: https://swapnil.mohite.in/

💡 Tech Behind the Build:
🧠 Frontend: React (Vite) + TailwindCSS — fast & beautiful
🐍 Backend: Python (Flask) — clean, reliable, and API-driven
☁️ Hosting: Vercel (@vercel/python runtime) — smooth deployments
🐳 Infra Experiments: Docker + Terraform — because DevOps never stops!
🔐 Contact Form: SMTP-secured — production-ready communication

💬 I’d love your thoughts!
If it inspires you —
❤️ Drop a like
💭 Leave a comment
🔁 Share it with your network
🤝 Let’s connect & collaborate!

DevOps #Cloud #AWS #Flask #React #Vite #TailwindCSS #Docker #Terraform #Vercel #Portfolio #Kubernetes #SRE #CICD #CloudEngineer #DevOpsEngineer #WebDev #OpenSource #TechCommunity

DevOps Shack: Multi-Cluster CI/CD DevOps Project 🌟

Swapnil Suresh Mohite — Wed, 28 Aug 2024 12:04:18 +0000

🚀 Introduction
A multi-cluster CI/CD pipeline further enhances resilience and scalability, allowing seamless management across different environments. This guide will walk you through setting up a multi-cluster CI/CD pipeline using GitHub Actions—from environment setup to full pipeline implementation. Let's get started! 💻✨

Linkedin
GitHub

🔧 Prerequisites
Before diving into the setup, make sure you have the following ready:

✅ GitHub account and repository for your project.
✅ Docker installed on your local machine.
✅ Kubernetes clusters set up on Amazon EKS.
✅ Basic understanding of CI/CD and Kubernetes.
✅ Necessary permissions for creating and managing GitHub Actions workflows.
With these in place, you’re all set to begin! 🚀🔗

🛠️ Setting Up the Environment

Setting Up the Runner for GitHub Actions First, let's configure a self-hosted runner to execute your CI/CD workflows.

Create a GitHub Repository:

🌐 Navigate to GitHub and create a new repository for your project.
💻 Clone the repository to your local machine to start working on it.
Configure GitHub Actions Runner:

🛠️ Go to your repository on GitHub, click on Settings > Actions > Runners.
🆕 Click New self-hosted runner and follow the instructions to set it up on your machine or server.
With the runner configured, your workflows can now be executed in a dedicated environment, giving you better control over the CI/CD process. 🖥️🔄

Configuring GitHub Repository Next, let's set up your GitHub repository for smooth integration with GitHub Actions.

Repository Setup:

📂 Initialize your repository with essential files like README, .gitignore, and LICENSE.
🚀 Push your initial codebase to GitHub to start building the CI/CD pipeline.
Create GitHub Actions Workflow:

📁 In your repository, create a .github/workflows directory to host your workflow files.
📝 Create a new YAML file (e.g., ci-cd-pipeline.yml) to define your workflow.
This setup lays the foundation for a structured and efficient CI/CD pipeline. 🗂️🔧

💻 CI/CD Pipeline Design

Continuous Integration (CI) CI automatically builds and tests code changes to catch issues early.

Define CI Workflow:

📝 Open your ci-cd-pipeline.yml file and define the stages for the CI process.
Testing and Static Code Analysis:

🔍 Extend your workflow to include testing and static code analysis with tools like JUnit and SonarQube.
Example YAML configuration:

name: CI Pipeline

on:
  push:
    branches:
      - main

jobs:
  build:
    runs-on: self-hosted
    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Set up JDK 11
        uses: actions/setup-java@v1
        with:
          java-version: '11'

      - name: Build with Maven
        run: mvn clean install

      - name: Run tests
        run: mvn test

      - name: SonarQube Scan
        env:
          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
        run: mvn sonar:sonar

This ensures every code change is automatically built and tested, catching issues early. 🧪✔️

Continuous Deployment (CD) CD automates the deployment of code changes to production environments.

Define CD Workflow:

🚀 Extend your CI workflow to include deployment stages.
Example YAML configuration:

- name: Deploy to Kubernetes
  uses: actions/kubernetes-action@v1.0.0
  with:
    kubeconfig: ${{ secrets.KUBECONFIG }}
    manifests: |
      k8s/deployment.yaml
      k8s/service.yaml

By automating the deployment process, you ensure that every code change passing CI is deployed to the right environment. 🌐🚀

🔒 Security and Quality Assurance
Ensuring security and code quality is crucial in any CI/CD pipeline.

Static Code Analysis Integrate SonarQube to detect code quality issues, bugs, and security vulnerabilities.

Integrate SonarQube:

🌐 Set up a SonarQube server or use a hosted service.
🔗 Create a SonarQube project and obtain the authentication token.
Example configuration:

- name: SonarQube Scan
  env:
    SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
  run: mvn sonar:sonar

This ensures your code meets quality and security standards before deployment. 🛡️🔍

Vulnerability Scanning Integrate Aqua Trivy to scan Docker images for known vulnerabilities.

Integrate Aqua Trivy:

🛠️ Install Trivy for container image scanning.
Example YAML configuration:

- name: Trivy Scan
  run: |
    docker pull your-docker-repo/your-app:${{ github.sha }}
    trivy image --severity HIGH,CRITICAL your-docker-repo/your-app:${{ github.sha }}

📦 Artifact Management
Build, tag, and store Docker images for deployment.

Docker Image Creation and Tagging Build Docker Images:

🛠️ Define a stage in your workflow to build Docker images.
Tag Docker Images:

🏷️ Tag images for different environments (e.g., dev, prod).
Push Docker Images:

📤 Push tagged Docker images to a registry like Docker Hub or Amazon ECR.
This ensures consistent and reliable deployments across environments. 🐳📦

🌍 Deployment Strategy
Deploy applications to multiple clusters using Kubernetes and Amazon EKS.

Multi-Cluster Kubernetes Deployment Kubernetes Configuration:

📜 Create Kubernetes manifests for your application and store them in your GitHub repository.
Deploy to Multiple Clusters:

🌐 Configure your workflow to deploy to multiple Kubernetes clusters.
Example YAML configuration:

- name: Deploy to Kubernetes
  uses: actions/kubernetes-action@v1.0.0
  with:
    kubeconfig: ${{ secrets.KUBECONFIG }}
    manifests: |
      k8s/deployment.yaml
      k8s/service.yaml

📈 Monitoring and Logging
Effective monitoring and logging are essential for smooth operations.

GitHub Actions Monitoring Monitor GitHub Actions: 📊 Use the GitHub Actions dashboard to monitor workflow runs and logs.
Trivy Post-Deployment Scanning Continuous Vulnerability Scanning: 🕵️ Schedule periodic scans of deployed images using Trivy to maintain security. This helps in quickly identifying and addressing any issues in the CI/CD pipeline. 🛡️👀

🛠️ Issue Tracking and Team Collaboration
Integrate tools for efficient issue tracking and team collaboration.

Integrating Jira Set Up Jira Integration: 🔗 Connect your GitHub repository to Jira for seamless issue tracking and task management.
Enhancing Team Collaboration Use Collaboration Tools: 💬 Leverage tools like Slack for real-time communication and CI/CD notifications. Example YAML configuration for Slack notifications:

- name: Notify Slack
  uses: slackapi/slack-github-action@v1.16.0
  with:
    slack-message: 'Build ${{ github.run_id }} has completed'
    channel-id: 'your-channel-id'
    slack-token: ${{ secrets.SLACK_TOKEN }}

This ensures your team stays informed and productive. 🤝💬

🎯 Conclusion
Setting up a multi-cluster CI/CD pipeline with GitHub Actions involves careful planning and configuration. By following this guide, you can establish a robust, scalable, and secure CI/CD pipeline that enhances your software development process. Happy DevOps-ing! 🚀🔧

DevOps #CI_CD #Kubernetes #GitHubActions #MultiCluster #Automation #CloudComputing #Docker #AmazonEKS #Security #DevOpsShack

Comprehensive DevSecOps Pipeline: Secure & Scalable Kubernetes Deployment with AWS EKS, ArgoCD and Jenkins Integration

Swapnil Suresh Mohite — Sun, 18 Aug 2024 12:43:00 +0000

This is a detailed guide for setting up an Advanced End-to-End DevSecOps Kubernetes Three-Tier Project using AWS EKS, ArgoCD, Prometheus, Grafana, and Jenkins. Below is the structured content for each step, allowing for comprehensive deployment, security, and monitoring of a scalable application environment. This project introduces a robust three-tier architecture on AWS using Kubernetes, emphasizing DevOps best practices and security measures.
GitHub Repository:
LinkedIn

Project Introduction

Welcome to the End-to-End DevSecOps Kubernetes Project! This project will guide you through deploying, securing, and monitoring a three-tier application using AWS EKS and several DevSecOps tools. You'll gain hands-on experience with Infrastructure as Code (IaC), continuous integration, and continuous delivery (CI/CD) pipelines, security scanning, and monitoring, ensuring a secure and reliable deployment.

Project Overview

The project covers these key areas:

IAM User Setup
Create an IAM user on AWS with Administrator access for deployment and management activities.

Infrastructure as Code (IaC)
Use Terraform and AWS CLI to deploy a Jenkins server on an EC2 instance in AWS.

Jenkins Server Configuration
Install and configure Jenkins, Docker, Sonarqube, Terraform, Kubectl, AWS CLI, and Trivy on the Jenkins server.

EKS Cluster Deployment
Use eksctl commands to create an Amazon EKS cluster on AWS, a managed Kubernetes service.

Load Balancer Configuration
Configure an AWS Application Load Balancer (ALB) for the EKS cluster.

Amazon ECR Repositories
Create private repositories for frontend and backend Docker images on Amazon Elastic Container Registry (ECR).

ArgoCD Installation
Install and configure ArgoCD for continuous delivery and GitOps practices.

Sonarqube Integration
Integrate Sonarqube into the DevSecOps pipeline for code quality analysis.

Jenkins Pipelines
Set up Jenkins pipelines for deploying backend and frontend code to the EKS cluster.

Monitoring Setup
Implement monitoring for the EKS cluster using Helm, Prometheus, and Grafana.

ArgoCD Application Deployment
Deploy the three-tier application using ArgoCD, covering database, backend, frontend, and ingress components.

DNS Configuration
Configure DNS settings to make the application accessible via custom subdomains.

Data Persistence
Implement persistent volume and persistent volume claims for database pods to ensure data persistence.

Conclusion and Monitoring
Summarize key achievements and monitor the EKS cluster’s performance using Grafana.

Prerequisites
Before beginning this project, ensure you have:

An AWS account with permissions to create resources.
Terraform and AWS CLI installed on your local machine.
Basic familiarity with Kubernetes, Docker, Jenkins, and DevOps principles.

Step-by-Step Execution
Step 1: Create an IAM User and Generate AWS Access Key
Navigate to the AWS IAM service and create a new IAM user with AdministratorAccess.
Generate the AWS Access Key and download the CSV file for future reference.

Step 2: Install Terraform & AWS CLI
Install Terraform and AWS CLI using provided scripts.
Configure both tools with the access key generated in Step 1.

Step 3: Deploy the Jenkins Server Using Terraform
Clone the Git repository and modify the backend.tf file for Terraform configurations.
Initialize and apply Terraform to create the Jenkins server on AWS.

Step 4: Configure Jenkins
Log into the Jenkins server and install Jenkins, Docker, Sonarqube, Terraform, Kubectl, AWS CLI, and Trivy.
Access the Jenkins dashboard via the public IP and port 8080.

Step 5: Deploy the EKS Cluster Using eksctl
Install AWS Credentials and Pipeline plugins in Jenkins.
Configure AWS credentials in Jenkins and create an EKS cluster using eksctl commands.

Step 6: Configure Load Balancer on EKS
Create IAM policies and an OIDC provider for the Load Balancer.
Deploy the AWS Load Balancer Controller and validate its deployment.

Step 7: Create Amazon ECR Repositories
Create private repositories on Amazon ECR for the frontend and backend.
Configure ECR locally on the Jenkins server to push Docker images.

Step 8: Install & Configure ArgoCD
Create namespaces for ArgoCD and the three-tier application.
Install ArgoCD, expose it as a LoadBalancer, and access the dashboard via the LoadBalancer DNS.

Step 9: Configure Sonarqube for DevSecOps Pipeline
Access Sonarqube on the Jenkins server and create tokens and webhooks for code quality checks.
Configure Sonarqube projects for frontend and backend code in Jenkins pipelines.

Step 10: Install Required Plugins and Configure Jenkins
Install necessary Jenkins plugins for Docker, NodeJS, OWASP Dependency-Check, and SonarQube Scanner.
Configure Jenkins with SonarQube, Docker, and other tools to support CI/CD pipelines.

Step 11: Setup Monitoring for EKS Cluster
Install Prometheus and Grafana using Helm.
Access the Prometheus and Grafana dashboards via LoadBalancer DNS and configure monitoring.

Step 12: Deploy the Three-Tier Application Using ArgoCD
Configure the private repository in ArgoCD.
Deploy the application components (database, backend, frontend) using ArgoCD.

Conclusion
The project concludes with the successful deployment of a secure, monitored three-tier application using advanced DevSecOps practices. The use of Jenkins, ArgoCD, Prometheus, and Grafana on AWS EKS showcases the integration of continuous deployment, security scanning, and monitoring in a cloud-native environment. Explore and monitor the application performance using Grafana dashboards, ensuring the environment's stability and security.

GitHub Repository:
LinkedIn

DevSecOps #Kubernetes #AWS #EKS #ArgoCD #Jenkins #Prometheus #Grafana #CloudSecurity #CICD #Automation #InfrastructureAsCode #CloudComputing #Containerization #DevOps

This project guide will give you a comprehensive understanding of deploying and managing applications in a Kubernetes environment using DevSecOps principles.

Edureka DevOps Certification Project

Swapnil Suresh Mohite — Fri, 16 Aug 2024 11:24:15 +0000

I'm thrilled to share my journey through the Edureka DevOps Certification Project, where I tackled a real-world challenge for Abstergo Corp., a retail company looking to streamline their deployment process. This project involved building an end-to-end CI/CD pipeline that automated everything from code integration to deployment on a Kubernetes cluster.

Key Achievements:
Continuous Integration: Automated Jenkins pipelines triggered by GitHub commits.
Containerization: Dockerized applications, with images pushed to Docker Hub.
Continuous Deployment: Automated deployments to a Kubernetes cluster.
Scalability: Implemented Horizontal Pod Autoscaling (HPA) for optimal performance.
Monitoring: Set up Prometheus, Grafana, and Loki for comprehensive monitoring and logging.
If you're interested in getting hands-on with this project, feel free to ping me on LinkedIn : https://www.linkedin.com/in/swapnil-m-2424sm/ or check out the GitHub repository for all the details.
GitHub repository 📢 https://shorturl.at/y8cfj

DevOps #Kubernetes #CI_CD #CloudComputing #Automation #TechInnovation #ContinuousLearning #Edureka #Certification #TechCommunity #DevOpsJourney #Docker #GitHub #Jenkins #K8s #OpenSource #ProjectSharing #CareerGrowth #LearnWithMe #TechSkills #ITTraining

Create and Deploy AWS EKS Cluster with Terraform.

Swapnil Suresh Mohite — Sat, 04 May 2024 07:16:21 +0000

📌 A managed container service for running and scaling Kubernetes applications on-premises or in the cloud is Amazon EKS (Elastic Kubernetes Service).

📌With the Infrastructure as Code (IaC) tool HashiCorp Terraform, you can specify on-premises and cloud resources in human-readable configuration files that you can share, reuse, and version.

GitHub

❇Install AWS CLI: Begin by installing the AWS CLI to seamlessly connect Terraform with AWS. Follow the simple steps outlined in the AWS CLI Installation Guide.

❇Install Terraform: Install Terraform using the provided link in the Terraform Installation Guide.

❇Connect Terraform with AWS: Easily link Terraform with AWS by executing the aws configure command and inputting your AWS Security credentials.

❇Initialize Terraform: Clone the repository and initialize Terraform by running terraform init. This step sets up the Terraform environment, downloading necessary modules, providers, and configurations.

❇Review Configuration (Optional): For clarity, you can run terraform plan to preview the configuration before execution.

❇Apply Terraform Configuration: Finally, apply the Terraform configuration to create the EKS cluster within the VPC by executing terraform apply. This straightforward process simplifies the creation of your EKS infrastructure on AWS.

⚠Cleanup⚠

terraform destroy: command is a convenient way to destroy all remote objects managed by a particular Terraform configuration.

*🏷 Happy Learning!!! *

Terraform #AWS #EKS

DevOps #project #GitHub

AWS Certified Solutions Architect – Associate!

Swapnil Suresh Mohite — Tue, 05 Mar 2024 07:13:22 +0000

🚀 **

Exciting Achievement Unlocked: AWS Certified Solutions Architect – Associate!

** 🚀

Thrilled to announce that I've earned the prestigious AWS Certified Solutions Architect – Associate certification! 🎓 This journey has been a thrilling ride through the intricate landscapes of cloud architecture, and I'm honored to join the league of certified professionals at the forefront of innovation.

Solutions Architect

Edureka's DevOps Certification Project🏅🏅

Swapnil Suresh Mohite — Mon, 08 Jan 2024 05:44:11 +0000

Linkedin
Github
🏅🏅🏅🏅🏅🏅🏅🏅🏅🏅🏅🏅🏅🏅🏅🏅🏅🏅🏅🏅🏅

🏅🏅🏅🏅🏅🏅🏅🏅🏅🏅🏅🏅🏅🏅🏅🏅🏅🏅🏅🏅🏅

Problem Statement

AppleBite Co. is using Cloud for one of their products. The project uses modular components,
multiple frameworks and want the components to be developed by different teams or by 3rd-party
vendors.
The company’s goal is to deliver the product updates frequently to production with High quality &
Reliability. They also want to accelerate software delivery speed, quality and reduce feedback time
between developers and testers.
As development progressed, they are facing multiple problems, because of various technologies
involved in the project. Following are the problems:

- Building Complex builds is difficult
- Incremental builds are difficult to manage, and deploy

To solve these problems, they need to implement Continuous Integration & Continuous Deployment
with DevOps using following tools:

Git – For version control for tracking changes in the code files
Jenkins – For continuous integration and continuous deployment
Docker – For deploying containerized applications

Ansible - Configuration management tools
This project will be about how to do deploy code to dev/stage/prod etc, just on a click of button.

Business challenge/requirement

As soon as the developer pushes the updated code on the GIT master branch, a new test server
should be provisioned with all the required software. Post this, the code should be containerized and
deployed on the test server.
The deployment should then be built and pushed to the prod server.
All this should happen automatically and should be triggered from a push to the GitHub master
branch.

Steps for executing the solution:

• Use the Master VM for Jenkins, Ansible, GIT etc.
• Use the fresh instance for Jenkins Slave Node (Test Server)
• Change the IP address of the VMs accordingly
• Add Build Pipeline Plugin and Post-build task plugin to Jenkins on the master VM
• Install python, openssh-server and git on the slave node manually
• Use the image devopsedu/webapp and add your PHP website to it using a Dockerfile
• Push the PHP website, and the Dockerfile to a git repository

Below tasks should be automated through Jenkins by creating a pipeline:

Install and configure puppet agent on the slave node (Job 1)

Push an Ansible configuration on test server to install docker (Job 2)

Pull the PHP website, and the Dockerfile from the git repo and build and deploy your PHP docker container. After. (Job 3)

If Job 3 fails, delete the running container on Test Server

🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀🚀

#aws #Edureka #Jenkins #GitHub #Ansible #Docker #python

Linkedin
Github

Deploying Super Mario on Kubernetes🎮🎮

Swapnil Suresh Mohite — Wed, 20 Dec 2023 07:15:09 +0000

Hey folks, remember the thrill of 90's gaming? Let's step back in time and relive those exciting moments! With the game deployed on Kubernetes, it's time to dive into the nostalgic world of Mario. Grab your controllers, it's game time!

GIT
linkedin


https://www.linkedin.com/posts/activity-7143143843671048192-siWq?utm_source=share&utm_medium=member_desktop

Super Mario is a classic game loved by many. In this guide, we'll explore how to deploy a Super Mario game on Amazon's Elastic Kubernetes Service (EKS). Utilizing Kubernetes, we can orchestrate the game's deployment on AWS EKS, allowing for scalability, reliability, and easy management.

Prerequisites:

An Ubuntu Instance
IAM role
Terraform should be installed on instance
AWS CLI and KUBECTL on Instance

LET'S DEPLOY

> STEP 1: Launch Ubuntu instance

Sign in to AWS Console: Log in to your AWS Management Console.
Navigate to EC2 Dashboard: Go to the EC2 Dashboard by selecting "Services" in the top menu and then choosing "EC2" under the Compute section.
launch Instance: Click on the "Launch Instance" button to start the instance creation process.
Choose an Amazon Machine Image (AMI): Select an appropriate AMI for your instance. For example, you can choose Ubuntu image.
Choose an Instance Type: In the "Choose Instance Type" step, select t2.micro as your instance type. Proceed by clicking "Next: Configure Instance Details."
Configure Instance Details:

For "Number of Instances," set it to 1 (unless you need multiple instances).
Configure additional settings like network, subnets, IAM role, etc., if necessary.
For "Storage," click "Add New Volume" and set the size to 8GB (or modify the existing storage to 8GB).
Click "Next: Add Tags" when you're done.

Add Tags (Optional): Add any desired tags to your instance. This step is optional, but it helps in organizing instances.
Configure Security Group:

Choose an existing security group or create a new one.
Ensure the security group has the necessary inbound/outbound rules to allow access as required. 9.Review and Launch: Review the configuration details. Ensure everything is set as desired.

Select Key Pair:

Select "Choose an existing key pair" and choose the key pair from the dropdown.
Acknowledge that you have access to the selected private key file.
Click "Launch Instances" to create the instance.

Access the EC2 Instance: Once the instance is launched, you can access it using the key pair and the instance's public IP or DNS.

Ensure you have necessary permissions and follow best practices while configuring security groups and key pairs to maintain security for your EC2 instance.

STEP 2: Create IAM role

Search for IAM in the search bar of AWS and click on roles.

Click on Create Role

Select entity type as AWS service

Use case as EC2 and click on Next.

For permission policy select Administrator Access (Just for learning purpose), click Next.

Provide a Name for Role and click on Create role.

Role is created.

Now Attach this role to Ec2 instance that we created earlier, so we can provision cluster from that instance.

Go to EC2 Dashboard and select the instance.

Click on Actions --> Security --> Modify IAM role.

Select the Role that created earlier and click on Update IAM role

STEP 3: Cluster provision

Now clone this Repo.

git clone https://github.com/SwapnilM24/k8s-mario.git

change directory

cd k8s-mario

Provide the executable permission to script.sh file, and run it.

sudo chmod +x script.sh
./script.sh

This script will install Terraform, AWS cli, Kubectl, Docker.

Check versions

docker --version
aws --version
kubectl version --client
terraform --version

Now change directory into the EKS-TF

Run Terraform init

NOTE: Don’t forgot to change the s3 bucket name in the backend.tf file

cd EKS-TF
terraform init

Now run terraform validate and terraform plan

terraform validate
terraform plan

Now Run terraform apply to provision cluster.

terraform apply --auto-approve

Completed in 10mins

Update the Kubernetes configuration

Make sure change your desired region

aws eks update-kubeconfig --name EKS_CLOUD --region ap-south-1

Now change directory back to k8s-mario

cd ..

Let’s apply the deployment and service

Deployment

kubectl apply -f deployment.yaml
#to check the deployment 
kubectl get all

Now let’s apply the service

Service

kubectl apply -f service.yaml
kubectl get all

Now let’s describe the service and copy the LoadBalancer Ingress

kubectl describe service mario-service

Paste the ingress link in a browser and you will see the Mario game.

Let’s Go back to 1985 and play the game like children.

Destruction :

Let's remove the service and deployment first

kubectl get all
kubectl delete service mario-service
kubectl delete deployment mario-deployment

Let’s Destroy the cluster

terraform destroy --auto-approve

After 10mins Resources that are provisioned will be removed.

Thank you for joining this nostalgic journey to the 90s! We hope you enjoyed rekindling your love for gaming with the deployment of the iconic Mario game on Kubernetes. Embracing the past while exploring new technologies is a true testament to the timeless allure of classic games. Until next time, keep gaming and reliving those fantastic memories! 👾🎮.

Building Cloud Native Monitoring Application on Kubernetes and AWS ECR 🚀 🚀 🚀

Swapnil Suresh Mohite — Sat, 09 Dec 2023 09:35:12 +0000

In the ever-evolving world of DevOps and cloud computing, the need for robust and scalable monitoring solutions is paramount. As applications grow more complex and distributed, having insights into their performance and resource utilization becomes essential. In this tutorial, we’ll take you through the journey of creating a Cloud Native Monitoring Application using Flask, Docker, Kubernetes (K8s), and Amazon EKS.

GitHub

Linkdin

Prerequisites !
(Things to have before starting the projects)

 AWS Account.
 Programmatic access and AWS configured with CLI.
 Python3 Installed.
 Docker and Kubectl installed.
 Code editor (Vscode)

Part 1: Deploying the Flask application locally
Step 1: Clone the code

Start by cloning the project repository to your local machine.

git clone https://github.com/SwapnilM24/cloud-native-monitoring-app.git

Step 2: Install dependencies

The application utilizes Python libraries like psutil, Flask, Plotly, and boto3. Install them using pip:

pip3 install -r requirements.txt

You can also go ahead with pip install -r requirements.txt in the whole project

Step 3: Run the application

Navigate to the project’s root directory and execute the following command:

python3 app.py

This will start the Flask server on localhost:5000. You can access the application by opening your browser and going to http://localhost:5000/.

Part 2: Dockerizing the Flask application
Step 1: Create a Dockerfile

In the project’s root directory, create a Dockerfile with the following contents:

Use the official Python image as the base image

FROM python:3.9-slim-buster

# Set the working directory in the container
WORKDIR /app
# Copy the requirements file to the working directory
COPY requirements.txt .
RUN pip3 install --no-cache-dir -r requirements.txt
# Copy the application code to the working directory
COPY . .
# Set the environment variables for the Flask app
ENV FLASK_RUN_HOST=0.0.0.0
# Expose the port on which the Flask app will run
EXPOSE 5000
# Start the Flask app when the container is run
CMD ["flask", "run"]

Step 2: Build the Docker image

To build the Docker image, execute the following command:

docker build -t <image_name> .

Step 3: Run the Docker container

Run the Docker container with the following command:

docker run -p 5000:5000 <image_name>

This will start the Flask server in a Docker container on localhost:5000. You can access the application the same way as before.

Part 3: Pushing the Docker image to ECR
Step 1: Create an ECR repository

Using Python and Boto3, create an Amazon ECR repository:

import boto3

# Create an ECR client
ecr_client = boto3.client('ecr')
# Create a new ECR repository
repository_name = 'my-ecr-repo'
response = ecr_client.create_repository(repositoryName=repository_name)
# Print the repository URI
repository_uri = response['repository']['repositoryUri']
print(repository_uri)

Step 2: Push the Docker image to ECR

Push the Docker image to the created ECR repository using the following commands:

docker push <ecr_repo_uri>:<tag>

Part 4: Creating an EKS cluster and deploying the app using Python
Step 1: Create an EKS cluster

Create an EKS cluster and add a node group.

Step 2: Create a node group

Create a node group in the EKS cluster. Remember to create security groups and roles in IAM for specific clusters. Use t2.micro to stay in free tier and create 2 nodes in a node group while creating cluster.

Step 3: Create deployment and service

Using Python and the Kubernetes client library, create a deployment and service for your Flask application. Be sure to replace <image_uri> with the URI of your Docker image.

from kubernetes import client, config

# Load Kubernetes configuration
config.load_kube_config()
# Create a Kubernetes API client
api_client = client.ApiClient()
# Define the deployment
deployment = client.V1Deployment(
    metadata=client.V1ObjectMeta(name="my-flask-app"),
    spec=client.V1DeploymentSpec(
        replicas=1,
        selector=client.V1LabelSelector(
            match_labels={"app": "my-flask-app"}
        ),
        template=client.V1PodTemplateSpec(
            metadata=client.V1ObjectMeta(
                labels={"app": "my-flask-app"}
            ),
            spec=client.V1PodSpec(
                containers=[
                    client.V1Container(
                        name="my-flask-container",
                        image="<image_uri>",
                        ports=[client.V1ContainerPort(container_port=5000)]
                    )
                ]
            )
        )
    )
)
# Create the deployment
api_instance = client.AppsV1Api(api_client)
api_instance.create_namespaced_deployment(
    namespace="default",
    body=deployment
)
# Define the service
service = client.V1Service(
    metadata=client.V1ObjectMeta(name="my-flask-service"),
    spec=client.V1ServiceSpec(
        selector={"app": "my-flask-app"},
        ports=[client.V1ServicePort(port=5000)]
    )
)
# Create the service
api_instance = client.CoreV1Api(api_client)
api_instance.create_namespaced_service(
    namespace="default",
    body=service
)

Ensure that you replace <image_uri>on line 25 with the actual URI of your Docker image.

After running the Python script eks.py, your deployment and service will be created. You can check their status using the following commands:

kubectl get deployment -n default  # Check deployments
kubectl get service -n default    # Check service
kubectl get pods -n default       # Check pods

Once your pod is up and running, run the port-forward command to expose the service:

kubectl port-forward service/<service_name> 5000:5000

Congratulations! You’ve successfully created a Cloud Native Monitoring Application and deployed it on Kubernetes with AWS EKS. This application can be extended to monitor various resources and provide valuable insights into your cloud infrastructure. Explore further and enhance your DevOps skills! 🚀

Explored the deployment of a 2048 Game Application on AWS EKS

Swapnil Suresh Mohite — Tue, 05 Dec 2023 03:17:56 +0000

🚀 Completed an end-to-end Kubernetes project. Explored the deployment of a 2048 Game Application on AWS EKS (Elastic Kubernetes Service) using Fargate and an Application Load Balancer Ingress Controller.

🛠️ Steps involved:

Set up prerequisites: Install awscli, eksctl, and kubectl,helm
Installed EKS with Fargate. **ekctl create cluster --name --region --fargate Note:: fargate is serverless computing service like aws lamda,choosing fargate service other than ec2 is cost optimized
Acquired or updated the KubeConfig file for CLI access to cluster resources. **aws eks update-kubeconfig --name --region
For deploying the pods other then the default namespaces we need to create the new namespace..for this deploy the new fargate profile and allow the pods to run on the new namespace .. **for eg namespace :: game-2048. 5.Create the custom fargate profile allowing the namespace created to deploy the pods in that.. eksctl create fargateprofile \ --cluster prod-web-hyd-eks \ --region=ap-south-2 \ --name fargate-1 \ --namespace game-2048
Deployed the 2048 app as a K8s Pod, created a corresponding service, and set up an Ingress resource for traffic routing. kubectl apply -f
Implemented the Ingress Controller to automate ALB Controller creation.
Established an IAM OIDC Provider to grant ALB Controller access to the Application Load Balancer.
Created a service account with an IAM Role and Policy for Load Balancer access. $ eksctl create iamserviceaccount --cluster=prod-web-hyd-eks --namespace=game-2048 --name=aws-load-balancer-controller --role-name awsELKloadbalancerRole --attach-policy-arn= --approve
Deployed ALB Controller using Helm Charts, interfacing with the service account. helm install aws-load-balancer-controller eks/aws-load-balancer-controller \ -n game-2048 \ --set clusterName= \ --set serviceAccount.create=false \ --set serviceAccount.name= \ --set region= \ --set vpcId=
Accessed the deployed 2048 application with the DNS URL of the Load Balancer in the public subnet.

linkedin
GitHub

#kubernetes 
#AWS 
#EKS 
#DevOps
#CloudComputing .🎮🚢

🚀The Netflix DevSecOps Project 🚀

Swapnil Suresh Mohite — Mon, 13 Nov 2023 16:42:44 +0000

Hi connections.
I'm thrilled to announce the completion of a DevSecOps project ✨ . The goal was to set up a cloud-based Netflix clone.

🚀 The Netflix DevSecOps Project 🚀

Phase 1: Initial Setup and Deployment
✅ Launch EC2 (Ubuntu 22.04):
Provisioned an EC2 instance on AWS with Ubuntu
22.04.
✅ Connected to the instance using SSH.
✅ Clone the Code:
Updated all packages and cloned the application code
from GitHub.
Install Docker and Run the App Using a Container:
Set up Docker on the EC2 instance.
Built and ran the Netflix clone application using Docker
containers.
Get the API Key:
Obtained the TMDB API key for the application.
Phase 2: Security
✅ Installed SonarQube and Trivy for vulnerability
scanning.
✅ Integrated SonarQube with the CI/CD pipeline.
Phase 3: CI/CD Setup
✅ Installed Jenkins for automation.
✅ Configured Jenkins plugins and tools for the CI/CD
pipeline.
Created a Jenkins pipeline for application deployment.
Phase 4:Monitoring
Installed Prometheus and Grafana for monitoring.
✅ Set up Node Exporter to collect system-level metrics.
✅ Configured Prometheus to scrape metrics from Node
Exporter.
Created Grafana dashboards for visualization.
Phase 5: Notification
Implemented email notifications in Jenkins for alerts.
Phase 6: Kubernetes
Created a Kubernetes cluster with node groups.
Monitored Kubernetes with Prometheus and Node
Exporter.
Phase 7: Cleanup
Terminated AWS EC2 instances that were no longer
needed.
Github

Linkdin

Tools used: 🛠

Jenkins
Docker
SonarQube
Trivy
Email
Prometheus
Grafana
Kubernetes
ArgoCD

Jenkins Pipeline for Java based application using Maven, SonarQube, Argo CD and Kubernetes

Swapnil Suresh Mohite — Sun, 08 Oct 2023 17:17:06 +0000

End-to-end CI/CD with Jenkins and GitHub integration, deployment of a Java base application on an AWS EC2 instance, and exploration of Minikube for Kubernetes deployment! 🎉 🔧 Tools and technologies used: AWS created an Ubuntu AWS-EC2 instance; Jenkins and Docker were installed on the Ubuntu EC2 instance; and a secure connection was established between Jenkins and GitHub using an SSH key produced on EC2.Jenkins produces Docker images from the GitHub-hosted Dockerfile and runs containers * The image was then submitted to Docker Hub, preparing it for Kubernetes Minikube was used to deploy the application also using Argo CD.

This project showed me the power of automation, CI/CD, containerization, Argo CD, and Kubernetes orchestration, as well as allowing me to improve my DevOps skills. It's incredible to watch how different technologies work together to improve development and deployment procedures. I'd want to thank the fantastic DevOps community on YouTube for their constant support in assisting me in transitioning from fundamental knowledge to hands-on expertise, as well as my amazing tutor Abhishek Veeramalla. 🚀 Your suggestions and collaborative spirit have been invaluable! I'm eternally grateful to all of the incredible content authors that diligently share their expertise and experiences, paving the path for other DevOps enthusiasts like me to prosper in the world.@Abhishekveeram deserves special recognition.

Prerequisites:

Java application code hosted on a Git repository
Jenkins server
Kubernetes cluster
Argo CD

Steps:

1. Install the necessary Jenkins plugins:
   1.1 Git plugin
   1.2 Maven Integration plugin
   1.3 Pipeline plugin
   1.4 Kubernetes Continuous Deploy plugin

2. Create a new Jenkins pipeline:
   2.1 In Jenkins, create a new pipeline job and configure it with the Git repository URL for the Java application.
   2.2 Add a Jenkinsfile to the Git repository to define the pipeline stages.

3. Define the pipeline stages:
    Stage 1: Checkout the source code from Git.
    Stage 2: Build the Java application using Maven.
    Stage 3: Run unit tests using JUnit and Mockito.
    Stage 4: Run SonarQube analysis to check the code quality.
    Stage 5: Package the application into a JAR file.
    Stage 6: Run user acceptance tests on the deployed application.
    Stage 7: Promote the application to a production environment using Argo CD.

4. Configure Jenkins pipeline stages:
    Stage 1: Use the Git plugin to check out the source code from the Git repository.
    Stage 2: Use the Maven Integration plugin to build the Java application.
    Stage 3: Use the JUnit and Mockito plugins to run unit tests.
    Stage 4: Use the SonarQube plugin to analyze the code quality of the Java application.
    Stage 5: Use the Maven Integration plugin to package the application into a JAR file.
    Stage 6: Use the Kubernetes Continuous Deploy plugin to deploy the application to a test environment using Helm.
    Stage 7: Use a testing framework like Selenium to run user acceptance tests on the deployed application.
    Stage 8: Use Argo CD to promote the application to a production environment.

5. Set up Argo CD:
    Install Argo CD on the Kubernetes cluster.
    Set up a Git repository for Argo CD to track the changes in the Helm charts and Kubernetes manifests.
    Create a Helm chart for the Java application that includes the Kubernetes manifests and Helm values.
    Add the Helm chart to the Git repository that Argo CD is tracking.

6. Configure Jenkins pipeline to integrate with Argo CD:
   6.1 Add the Argo CD API token to Jenkins credentials.
   6.2 Update the Jenkins pipeline to include the Argo CD deployment stage.

7. Run the Jenkins pipeline:
   7.1 Trigger the Jenkins pipeline to start the CI/CD process for the Java application.
   7.2 Monitor the pipeline stages and fix any issues that arise.

This end-to-end Jenkins pipeline will automate the entire CI/CD process for a Java application, from code checkout to production deployment, using popular tools like SonarQube, Argo CD, and Kubernetes.

Youtube
🚀💡
Git
🚀💡
linkedin

DEV Community: Swapnil Suresh Mohite

🚀 Just Launched — My Personal Cloud & DevOps Portfolio! 🌩️

DevOps #Cloud #AWS #Flask #React #Vite #TailwindCSS #Docker #Terraform #Vercel #Portfolio #Kubernetes #SRE #CICD #CloudEngineer #DevOpsEngineer #WebDev #OpenSource #TechCommunity

DevOps Shack: Multi-Cluster CI/CD DevOps Project 🌟

DevOps #CI_CD #Kubernetes #GitHubActions #MultiCluster #Automation #CloudComputing #Docker #AmazonEKS #Security #DevOpsShack

Comprehensive DevSecOps Pipeline: Secure & Scalable Kubernetes Deployment with AWS EKS, ArgoCD and Jenkins Integration

Project Introduction

Project Overview

DevSecOps #Kubernetes #AWS #EKS #ArgoCD #Jenkins #Prometheus #Grafana #CloudSecurity #CICD #Automation #InfrastructureAsCode #CloudComputing #Containerization #DevOps

Edureka DevOps Certification Project

DevOps #Kubernetes #CI_CD #CloudComputing #Automation #TechInnovation #ContinuousLearning #Edureka #Certification #TechCommunity #DevOpsJourney #Docker #GitHub #Jenkins #K8s #OpenSource #ProjectSharing #CareerGrowth #LearnWithMe #TechSkills #ITTraining

Create and Deploy AWS EKS Cluster with Terraform.

Terraform #AWS #EKS

DevOps #project #GitHub

AWS Certified Solutions Architect – Associate!

Exciting Achievement Unlocked: AWS Certified Solutions Architect – Associate!

Edureka's DevOps Certification Project🏅🏅

Problem Statement

Business challenge/requirement

Steps for executing the solution:

Deploying Super Mario on Kubernetes🎮🎮

Building Cloud Native Monitoring Application on Kubernetes and AWS ECR 🚀 🚀 🚀

GitHub

Linkdin

Use the official Python image as the base image

Explored the deployment of a 2048 Game Application on AWS EKS

🚀The Netflix DevSecOps Project 🚀

🚀 *The Netflix DevSecOps Project *🚀

Jenkins Pipeline for Java based application using Maven, SonarQube, Argo CD and Kubernetes

🚀 The Netflix DevSecOps Project 🚀