WEATHER APP DEPLOYMENT WITH

MONITORING IN DEVOPS
MINI PROJECT REPORT

Submitted by

Karishma R.K [ RA2211028010071]

Nitika Pandey [RA2211028010073]

Under the Guidance of

Dr. Radhika R

21PE333P – Essentials in Cloud and DevOps

DEPARTMENT OF NETWORKING AND COMMUNICATIONS

FACULTY OF ENGINEERING AND

TECHNOLOGY SCHOOL OF

NETWORKING AND

COMMUNICATIONS

SRM INSTITUTE OF SCIENCE AND TECHNOLOGY

KATTANKULATHUR
MAY 2025
 SRM INSTITUTION OF SCIENCE AND TECHNOLOGY
(Under Section 3 of UGC Act, 1956)

BONAFIDE CERTIFICATE

Certified that the 21PE333P-Essestials in Cloud and DevOps course project report titled
“WEATHER APP DEPLOYMENT WITH MONITORING IN DEVOPS” is the bonafide
work done by KARISHMA R.K [RA2211028010071] and NITIKA PANDEY
[RA2211028010073] of III Year/VI Sem B.Tech(CSE-CLOUD COMPUTING) who carried
out the mini project under my supervision.

SIGNATURE SIGNATURE
Faculty In-Charge Dr.M.Lakshmi
Dr. Radhika R Associate Head of the Department
Professor, Professor and Head
Department of Networking and
Department of Networking and Communications,
Communications,
SRM Institute of Science and Technology
Kattankulathur SRM Institute of Science and Technology
Kattankulathur
 ABSTRACT

This project presents the design, development, and deployment of a real-time Weather
Application using DevOps methodologies, focusing on automation, scalability, and
maintainability. The core functionality of the application allows users to retrieve current
weather conditions such as temperature, humidity, wind speed, and general atmospheric status
by entering a city name. The application fetches data from a public weather API and displays it
through a clean and intuitive front-end interface. To ensure reliability and consistency across
environments, the backend weather API is containerized using Docker. Docker allows
environment-independent deployments and simplifies orchestration by packaging the
application along with its dependencies into isolated containers. GitHub Actions is utilized to
build a CI/CD pipeline that automates code integration, testing, and deployment, significantly
reducing human intervention and deployment time. The DevOps pipeline ensures that any
update to the source code is automatically built, tested, and deployed to the cloud. Additionally,
the system is integrated with Prometheus for real-time monitoring and Grafana for dashboard-
based performance visualization. This enables developers to track application health,
performance metrics, and detect anomalies at an early stage. The project demonstrates an end-
to-end implementation of a DevOps workflow, highlighting the practical integration of
containerization, automated deployment, and monitoring for a simple yet effective web-based
application. It provides a foundation for extending similar DevOps practices to more complex,
enterprise-level software systems.
 ACKNOWLEDGEMENT

We express our heartfelt thanks to our honourable Vice Chancellor

Dr. C. MUTHAMIZHCHELVAN, for being the beacon in all our endeavours.
We would like to express my warmth of gratitude to our Registrar Dr. S
Ponnusamy, for his encouragement.

We express our profound gratitude to our Dean (College of Engineering and

Technology) Prof. M. Leenus J Martin , for bringing out novelty in all executions.
We would like to express my heartfelt thanks to Chairperson, School of
Computing Dr. Revathi Venkataraman, for imparting confidence to complete
my course project.

We wish to express my sincere thanks to Course Audit Professors Dr. Uma , Professor,
Department of CTech and Course Coordinator Dr L.Anand Department of
Networking and Communications for their constant encouragement and support.

We are highly thankful to our Course project Faculty Dr Radhika R, Associate

Professor , Department of Networking and Communications, for her assistance,
timely suggestion and guidance throughout the duration of this course project.
We extend my gratitude to our HOD Dr.M.Lakshmi Professor and Head, Department
of Networking and Communications and my Departmental colleagues for their Support.

Finally, we thank our parents and friends near and dear ones who directly and indirectly
contributed to the successful completion of our project. Above all, I thank the almighty
for showering his blessings on me to complete my Course project.
 TABLE OF CONTENTS

Sr. No. Title Page No.

1. Introduction 6

2. Literature Survey 7-9

3. Requirement Analysis 9-11

4. Architecture and Design 11

5. Implementation 12-22

6. Experiment Result and Analysis 23-26

7. Future Scope 27

8. Conclusion 28

9. References 29
 INTRODUCTION

In recent years, the adoption of DevOps practices has transformed the software development
and deployment landscape. DevOps is a combination of development and operations, aiming to
shorten the software development life cycle while delivering features, fixes, and updates
frequently in close alignment with business objectives. It emphasizes automation, collaboration,
continuous integration, continuous delivery (CI/CD), infrastructure as code (IaC), and
monitoring.
This project focuses on implementing a fully automated DevOps pipeline for a weather
forecasting web application. The goal is to demonstrate how various modern DevOps tools and
practices can be integrated to create a seamless and efficient deployment workflow. The
application is hosted on GitHub and uses GitHub Actions for automating build, test, and
deployment processes.
Infrastructure provisioning is achieved using Terraform, enabling reproducible and scalable
infrastructure setup on Amazon Web Services (AWS). The application is containerized using
Docker and deployed on a Kubernetes cluster that is configured on an EC2 instance
provisioned via Terraform. Kubernetes provides automated container orchestration,
management, and scaling.
For observability, Prometheus is used to collect application and system metrics, while
Grafana offers a user-friendly dashboard to visualize real-time data. These tools help monitor
system health and performance, which is crucial in any production-grade environment.
The motivation behind this project is to gain practical experience in implementing a complete
DevOps lifecycle and to showcase how DevOps practices improve software delivery speed,
reliability, and scalability. By the end of the project, the application is fully automated from
code commit to deployment and monitoring, demonstrating the real-world impact of DevOps
methodologies.
 LITERATURE SURVEY

The adoption of DevOps practices has revolutionized the way software is developed,
deployed, and maintained. This survey reviews key technologies used in this project—
GitHub Actions, Terraform, Docker, Kubernetes, Prometheus, and Grafana—and
summarizes relevant literature and implementations.

2.1 Continuous Integration and Continuous Deployment (CI/CD)

CI/CD is a foundational DevOps practice that enables faster, automated delivery of
applications. GitHub Actions, a modern CI/CD tool, allows seamless integration with
code repositories for building, testing, and deploying software with minimal manual
intervention.
In a real-world CI/CD implementation using GitHub Actions, Terraform, and
Kubernetes, developers demonstrate how to manage infrastructure and deployments
efficiently by integrating build pipelines directly into version control workflows
(medium.com).

2.2 Infrastructure as Code (IaC) with Terraform

Terraform by HashiCorp enables declarative infrastructure provisioning, making
cloud resource management version-controlled and reproducible. It supports multi-
cloud environments and is widely used for setting up scalable infrastructure
automatically.
One implementation illustrates using Terraform to provision AWS infrastructure and
tie it into CI/CD workflows. This not only eliminates manual cloud configuration but
ensures consistency across environments (aws.plainenglish.io).
 2.3 Containerization with Docker
Docker plays a pivotal role in DevOps by enabling applications to run in lightweight,
portable containers. It simplifies dependency management and guarantees consistency
across development, staging, and production environments.
In this project, Docker is used to containerize the weather app, making it easily
deployable across environments. Literature shows Docker’s effectiveness when
integrated with Kubernetes, allowing developers to package their applications and
deploy them efficiently in orchestrated clusters (docker.com).

2.4 Container Orchestration with Kubernetes

Kubernetes automates the deployment, scaling, and management of containerized
applications. It is essential for running Docker containers in production environments,
ensuring high availability and resilience.
In DevOps pipelines, Kubernetes works closely with Docker to manage multi-
container deployments. Articles demonstrate how Kubernetes can be configured via
GitHub Actions and Terraform for full-stack automation (medium.com).

2.5 Monitoring with Prometheus and Grafana

Monitoring and observability are key for maintaining system health and performance.
Prometheus collects and stores metrics, while Grafana visualizes them via
customizable dashboards.
A recent tutorial highlights how integrating Prometheus into CI/CD pipelines
provides real-time insights and alerts. Grafana complements this by presenting the
metrics in an accessible and actionable format (duplocloud.com).
 This literature review confirms that combining GitHub Actions, Docker, Terraform,
Kubernetes, Prometheus, and Grafana forms a powerful, automated DevOps pipeline.
These tools collectively enhance deployment speed, consistency, scalability, and
observability in modern software projects.

REQUIREMENT ANALYSIS

To build an efficient and automated DevOps pipeline for the weather forecasting web
application, it is essential to define both functional and non-functional requirements.
These requirements guide the design, implementation, and evaluation of the system to
ensure it meets both technical and user expectations.

3.1 Functional Requirements:

Functional requirements describe the key operations and behaviors that the system
must perform. For this project, the functional requirements include:
1. Code Repository Integration
The system must integrate with a GitHub repository to access source code and
trigger automated workflows.
2. Continuous Integration and Continuous Deployment (CI/CD)
On every code push to the main branch, the system must automatically:
o Build the application using Docker.
o Run tests (if any are present).
o Deploy the containerized application to the Kubernetes cluster.
3. Infrastructure Provisioning with Terraform
The system must use Terraform scripts to provision and configure AWS resources
such as EC2 instances for hosting the Kubernetes cluster.
4. Containerization with Docker
The application must be containerized using Docker to ensure consistency across
 environments.
5. Kubernetes Cluster Management
The Kubernetes cluster must be set up and maintained to host and manage the
application containers.
6. Monitoring and Visualization
The system must use Prometheus to collect metrics and Grafana to visualize them,
enabling real-time monitoring of application health and resource usage.
7. Version Control and Rollback
Each deployment should be versioned, and the system should allow rollbacks to
previous stable versions if needed.

3.2 Non-Functional Requirements:

Non-functional requirements define system attributes such as performance, reliability,
scalability, and usability. For this project, they include:
1. Scalability
The system should be able to scale horizontally to handle increased traffic or
larger workloads by deploying additional container replicas.
2. Reliability and Availability
The application must be highly available, with Kubernetes ensuring that
containers are automatically restarted in case of failure.
3. Security
o Secure access to AWS resources using IAM roles and policies.
o Use of environment variables and secrets management to handle sensitive
information in GitHub Actions and Kubernetes.
4. Automation
All infrastructure and deployment steps must be automated with minimal manual
intervention, ensuring consistency and reducing human error.
5. Portability
Docker containers and Terraform scripts must allow the solution to be deployed
across different environments without significant changes.
6. Maintainability
The system should be modular and well-documented to facilitate future updates or
enhancements with minimal effort.
7. Performance
The deployed application should have low latency and fast response times under
normal load conditions.

ARCHITECTURE AND DESIGN

 IMPLEMENTATION
Infrastructure as a code AC (Using Terraform)
Containerization using Docker
Backend of the project

Monitoring and Logging using Prosthemus and Grafanna

Github Repository
Github Actions
Database
EXPERIMENTAL RESULTS AND ANALYSIS
The weather application was tested extensively to evaluate its functionality, reliability, and
deployment efficiency using Docker-based orchestration and GitHub Actions for CI/CD.

1. Functional Testing Results

● Test Case 1: Valid City Input

o Input: Chennai
o Expected Outcome: Weather information should be fetched and displayed
o Actual Output:
▪ Temperature: 25.61°C

▪ Humidity: 53%

▪ Wind Speed: 7.06 km/h

▪ Condition: Clear Sky

▪ Recommendation and Additional Advice: Wear sunglasses and apply

sunscreen
o Result: Pass
 ● Test Case 2: Empty City Input

o Input: (Blank input)

o Expected Outcome: Application should handle gracefully without crashing
o Actual Output: Application returned no weather data, as expected
o Result: Pass
These results confirm that the app handles both valid and invalid inputs reliably and returns
accurate weather data when available.

2. CI/CD and Docker Orchestration

● CI/CD Tool Used: GitHub Actions

● Workflow:

o Code commit triggers GitHub Actions

o Weather API is packaged into a Docker image
o Docker container is built and run locally or in a cloud VM
o Automated scripts handle container startup and configuration
● Observations:

o Docker ensured consistent environment across development and production

o CI/CD pipeline executed without manual intervention
o Logs confirmed successful image build and container run on every commit

3. Performance and Monitoring

● Average API Response Time: ~1.2 seconds

● System Availability: No downtime during the test period

● Concurrency: Application handled multiple requests simultaneously without delay

● Monitoring Tools Used: Prometheus and Grafana

o Provided insights into CPU usage, memory, and request load

o Helped identify and resolve minor performance bottlenecks
 FUTURE SCOPE
.

● Advanced Docker Orchestration: Introduce tools like Docker Swarm or explore

managed container services (like AWS ECS) for production-ready deployments.
● Secrets Management: Integrate a secure secrets manager (e.g., AWS Secrets Manager or
environment-level encryption) to handle sensitive data like API keys.
● Alerting System: Set up Prometheus Alertmanager to send real-time alerts through
Slack, email, or SMS when anomalies are detected.
● Horizontal Scaling: Implement traffic-based container scaling using custom scripts or
third-party Docker plugins.
● Better UI Features: Expand the frontend to allow user customization like preferred cities
or themes.
● Multi-Environment Setup: Set up development, staging, and production environments
with isolated configurations.
 CONCLUSION

The weather application project successfully demonstrated the effectiveness of DevOps

practices in building, deploying, and monitoring a scalable cloud-based application. By
leveraging Terraform for infrastructure provisioning, Docker for containerization and
orchestration, and GitHub Actions for CI/CD, we automated the entire deployment workflow
—greatly reducing manual intervention and improving consistency. Monitoring with
Prometheus and Grafana allowed for real-time observability, helping us track performance
and reliability effectively.
This hands-on experience helped us deeply understand how to integrate various tools into a
cohesive DevOps pipeline and strengthened our practical knowledge in cloud-based deployment
and monitoring.
 REFERENCES

1. KuberocketCI CI/CD Documentation

2. Dockerfile Reference - Docker Docs
3. Docker Compose File Reference
4. Terraform Expressions – HashiCorp
5. Terraform Docs GitHub Repository
6. Prometheus Monitoring with RabbitMQ
7. Prometheus-Grafana Monitoring Setup by Nitika
8. Project Source Code