INTERNSHIP REPORT ON

“CLOUD AND DEVOPS”

Submitted in partial fulfilment of requirements for the award of the degree of

BACHELOR OF TECHNOLOGY
IN
INFORMATION TECHNOLOGY
Submitted by

VALLABHAPURAPU BLESSY RANI (21761A1258)

Under supervision of

Mr. RAVINDRA CHANTI BABU (Asst Prof)

(Duration: May to June

2024) 2024-2025

DEPARTMENT OF INFORMATION TECHNOLOGY

LAKIREDDY BALIREDDY COLLEGE OF ENGINEERING
(AUTONOMOUS )
L.B.REDDY NAGAR, MYLAVARAM, NTRDist

Approved by AICTE, NewDelhi and permanently Affiliated to JNTU

Kakinada, NAAC Accertified with “A” grade, accertified by NBA under Tier-1
& Certified by ISO21001:2018, 14001:2015, 50001:2018
 LAKIREDDY BALIREDDY COLLEGE OF ENGINEERING
(An autonomous Institution since 2010)
(Approved by AICTE, NewDelhi and permanently Affiliated to JNTU Kakinada,
NAAC Accertified with “A” grade, accredited by NBA Tier-1 & Certified by
ISO21001:2018, 14001:2015, 50001:2018)
L.B.REDDY NAGAR, MYLAVARAM, NTRDist.

DEPARTMENT OF INFORMATION TECHNOLOGY

CERTIFICATE
This is to certify that internship entitled that “CLOUD ENGINEERING & DEVOPS” is a bonafide work
done and submitted by VALLABHAPURAPU BLESSY RANI(21761A1258) in the partial fulfilment of
requirement for the award of Bachelor of Technology in (INFORMATION TECHNOLOGY) at
Lakireddy Balireddy College Of Engineering, Mylavaram during the year 2024-2025.

Internship Coordinator Head Of The Department

Mr.B. RAVINDRA CHANTI BABU Dr. B. SRINIVASA RAO

Assistant Professor Professor

External Examiner
 ACKNOWLEDGEMENT

The success and final outcome of learning “CLOUD ENGINEERING & DEVOPS” required a lot of
guidance and assistance from many people and I am extremely privileged to have got this all along the
completion of my internship. All that I have done is only due to such supervision and assistance and I
would not forget to thank MR. RAVINDRA.

I humbly express my thanks to our principal Dr.K.AppaRao for extending his support and for providing
us with an environment to complete Internship successfully.

I deeply indebted to our Head Of Department Dr.B.Srinivasa Rao, who, modeled us both technically and
normally for achieving greater success in life.

I respect and thank to Mr.RAVINDRA for providing mean opportunity to do the course and Internship
and giving me all the support and guidance, which made me complete the course duly. I am thankful and
fortunate enough to get constant encouragement, support and guidance from all teaching staff of
DATAVALLEY which helped in successfully completing my “CLOUD ENGINEERING & DEVOPS
INTERNSHIP”.
 DECLARATION

I hereby declare that I have completed my 45 days Internship program at “DATA VALLEY” on the
domain of “CLOUD ENGINEERING & DEVOPS” from May 2024 to June 2024.I have worked with
full dedication during these one month of training for the award of degree of Lakireddy Bali Reddy
College of Engineering, Mylavaram, NTR District.

VALLABHAPURAPU BLESSY RANI

(Reg No:- 21761A1258)

 ABSTRACT

During my internship at DataValley India Pvt Ltd, I gained hands-on experience in Cloud Engineering
and DevOps, focusing on scalable infrastructure solutions and automation practices. My responsibilities
included configuring and managing cloud environments, deploying CI/CD pipelines, and monitoring
systems for optimal performance. I worked extensively with AWS services, Kubernetes, and Docker,
enhancing my technical proficiency in cloud-native technologies. Collaborating with senior engineers, I
contributed to projects aimed at streamlining deployment processes and improving system reliability. This
experience significantly developed my skills in cloud infrastructure management and DevOps
methodologies, preparing me for advanced roles in the field.
CERTIFICATE:
 INTRODUCTION

In the modern world, managing personal finances has become increasingly complex, driven by the
diversity of expenses and the convenience of digital transactions. Despite earning income, many
individuals struggle to maintain a balanced budget or track their spending effectively. This can lead to
overspending, debt, and an overall lack of financial stability. Financial literacy and discipline are more
important ever, yet they remain challenging for many due to a lack of structured, accessible tools to assist
with everyday financial tracking and budgeting. A Personal Expense Tracker offers a practical solution to
these issues by enabling users to record, analyze, and control their expenditures.
A Personal Expense Tracker is a mobile or web-based application designed to help
individuals monitor their daily expenses in a simple and intuitive way. The application provides an easy-
to-use platform where users can log their spending, categorize transactions, and visualize their financial
habits through charts and reports. By delivering insights into personal spending behaviour, a personal
expense tracker empowers users to make informed financial decisions and align their spending with their
financial goals. One of the primary objectives of a Personal Expense Tracker is to make financial
management accessible to everyone, regardless of their level of financial expertise. The tool typically
includes essential features like categorizing expenses (such as food, utilities, entertainment, and
transport), setting spending limits or budgets, and generating reports that summarize spending patterns
over time. Some advanced versions may also offer bill reminders, financial goal-setting, and integration
with bank accounts or payment services, further streamlining the user’s financial tracking process. This
project aims to develop a comprehensive and user-friendly Personal Expense Tracker that provides an
intuitive interface and valuable financial insights. By equipping users with real-time data on their
financial habits, the application will foster greater financial awareness and encourage responsible
spending. Ultimately, this tool seeks to empower individuals to take control of their finances, reduce
financial stress, and achieve their long-term financial aspirations.

1. Overview of DataValley India Pvt Ltd

DataValley India Pvt Ltd is a prominent technology company specializing in cloud solutions, DevOps,
data analytics, and digital transformation services. With a strong commitment to innovation, the company
empowers clients by offering scalable, secure, and efficient cloud architectures and solutions. Known for
its industry expertise, DataValley provides comprehensive solutions that span from cloud consulting to
DevOps integration, helping businesses optimize their IT infrastructure and processes. My internship here
focused on two key domains: Cloud Engineering and DevOps, allowing me to gain hands-on experience
and apply theoretical knowledge in a real-world setting.
2. Project Objective and Scope

The main objective of my internship project was to gain practical experience in implementing and
managing cloud environments, developing CI/CD pipelines, and deploying automation solutions. The
project covered multiple facets of Cloud Engineering and DevOps, including cloud resource management,
containerization, infrastructure as code (IaC), and continuous integration/continuous deployment (CI/CD).
Through this internship, I aimed to understand industry-standard practices in deploying and scaling
applications efficiently and securely in a cloud environment. This hands-on project helped me bridge the
gap between theoretical knowledge and practical application in the field of cloud technology.

3. Importance of Cloud Engineering and DevOps

In today’s tech-driven world, Cloud Engineering and DevOps have become essential for modern IT
infrastructure management. Cloud Engineering enables organizations to create flexible and cost-effective
environments, allowing for scalable applications and seamless global access. Meanwhile, DevOps fosters
a collaborative culture between development and operations teams, enabling faster, more reliable software
delivery. By focusing on these fields, I gained insight into how organizations build and maintain efficient,
automated infrastructure that supports both speed and security—key factors in today’s competitive digital
landscape.

4. My Role and Responsibilities

As an intern, I was assigned tasks that involved working with cloud platforms, primarily Amazon Web
Services (AWS), along with containerization technologies like Docker and Kubernetes. My
responsibilities included setting up and managing cloud resources, automating deployments using CI/CD
pipelines, and monitoring systems to ensure optimal performance. I was also involved in using
Infrastructure as Code (IaC) tools like Terraform, which allowed me to define and provision infrastructure
in a repeatable manner. This hands-on involvement helped me gain experience in various DevOps tools
and cloud-native technologies essential for a cloud engineering role.

5. Technical Tools and Technologies Used

The project relied on a diverse set of technologies, focusing primarily on AWS services, containerization,
and automation. Docker and Kubernetes were essential for containerizing and orchestrating applications,
while Terraform allowed for infrastructure management. For CI/CD, I worked with Jenkins and GitHub
Actions, creating automated workflows that streamlined the code integration and deployment processes.
Additionally, I gained experience with monitoring and logging tools like Prometheus and Grafana, which
provided insights into system performance and helped detect issues early. This exposure to industry-
standard tools helped me build a strong foundation in cloud and DevOps practices.

6. Learning Outcomes and Career Impact

This internship at DataValley India Pvt Ltd was instrumental in developing my technical and problem-
solving skills in the field of cloud engineering and DevOps. Through hands-on practice and close
collaboration with industry experts, I acquired a deep understanding of cloud infrastructure management,
automation, and deployment best practices. The experience has not only prepared me for advanced roles
in these domains but has also given me a clearer perspective on the rapidly evolving nature of cloud
technologies and the importance of continuous learning in this field
 PROBLEM STATEMENT

The problem statements for the project were defined as follows:

Managing personal finances can be challenging, as many individuals struggle with tracking daily
expenses, categorizing spending, and making informed financial decisions. Existing tools often lack the
automation, real-time updates, and integration needed to make financial management efficient. A personal
expense tracker system that automates the expense tracking process, integrates with financial services like
bank accounts and payment platforms, and visualizes spending trends would be a valuable tool for users
looking to manage their finances effectively.

This project aims to build a scalable and secure Personal Expense Tracker with DevOps practices for
continuous integration, continuous delivery (CI/CD), and automation. The system will provide features
such as real-time expense tracking, automatic categorization, data visualization, and alerts for users'
spending habits. Using DevOps principles, the project will implement automated testing, deployment, and
monitoring, ensuring reliability and scalability as the user base grows. Additionally, the platform will
integrate with third-party APIs like bank accounts and payment systems, enabling seamless transaction
synchronization for a complete financial management experience.
 IMPLEMENTATION

Eclipse is an open-source integrated development environment (IDE) primarily used for

Java development, though it supports multiple programming languages and development tools through
plugins. It was initially developed by IBM but is now maintained by the Eclipse Foundation. Eclipse
provides a robust platform for software development with various features, such as code editing,
debugging, testing, and deployment tools, that enhance productivity.

Key Features of Eclipse

1. Multi-language Support: Eclipse primarily supports Java but can also handle other
languages like C, C++, Python, PHP, and JavaScript through plugins.
2. Plugin Architecture: Eclipse is highly extensible, allowing users to add plugins to support
additional programming languages, tools, or frameworks. This makes it a versatile choice
for developers working on diverse projects.
3. Integrated Tools: It includes essential development tools, such as a code editor with
syntax highlighting, auto-completion, and refactoring support. It also provides debugging
tools, version control integration (like Git), and support for various build systems (such as
Maven and Gradle).
4. Cross-Platform Compatibility: Eclipse runs on major operating systems,
including Windows, macOS, and Linux, making it accessible to a wide range of
developers.
5. Community and Ecosystem: Eclipse has a large community of developers and contributors
who provide support, plugins, and updates. It also supports many frameworks, libraries, and
application types, making it a flexible choice for developers in various fields.

Common Use Cases

 Java Development: Eclipse is widely used for Java programming, offering tools
specifically tailored for Java development, such as a Java compiler, debugger, and tools for
managing libraries and dependencies.
 Web Development: With plugins, Eclipse can support web development
technologies, including HTML, CSS, JavaScript, and various web frameworks.
 Enterprise Development: Eclipse supports development for enterprise-level
applications, including J2EE applications, and integrates with many popular enterprise
tools.
 Mobile and Embedded Development: Eclipse has specialized versions, such as Eclipse IDE
 for C/C++ Developers, and integrations for Android development, making it suitable for
mobile and embedded systems development.

2. Why Eclipse:

Eclipse is a popular choice for many developers for several reasons, particularly
because of its flexibility, extensive plugin ecosystem, and focus on Java development. Here’s
why developers often choose Eclipse:

1. Free and Open Source:

• Eclipse is open-source and free to use, making it accessible to everyone, from

beginners to professional developers, without licensing costs. Its open-source
nature also means that it’s continually improved by a global community, which
contributes plugins, fixes, and new features.
2. Extensive Plugin Ecosystem

 One of Eclipse's greatest strengths is its vast ecosystem of plugins. Developers can extend
the functionality of Eclipse to support nearly any development language, tool, or workflow.
Whether you’re working with Java, Python, JavaScript, PHP, or even machine learning
libraries, chances are there’s a plugin for it. This extensibility makes Eclipse versatile and
adaptable for a wide range of projects and environments.

3. Excellent Java Development Support

 Eclipse was originally developed for Java programming, so it has comprehensive support
for Java development. It includes tools for code completion, refactoring, and syntax
checking, as well as a powerful debugger specifically tailored for Java. Additionally,
Eclipse supports popular Java frameworks (like Spring and Hibernate), libraries, and build
tools (like Maven and Gradle), making it an ideal environment for Java developers.

4. Integrated Development Features

 Eclipse provides a wide range of built-in features that cover most aspects of the
software development lifecycle, including:
o Code editing with syntax highlighting, code folding, and auto-completion.
 o Debugging and profiling tools that let developers identify and fix issues within
the IDE.
o Version control integration for tools like Git, SVN, and Mercurial.
o Build automation support with tools like Maven, Gradle, and Ant.
 These features help streamline development by reducing the need to switch between
multiple applications and tools.

3. How to use Eclipse:

 Install Eclipse: Download and install Eclipse IDE from the Eclipse website.
 Set Up Workspace: Open Eclipse and select a workspace folder where your projects will
be stored.
 Create a New Project: Go to File > New > Java Project, name your project, and
click Finish.
 Create a Class: Right-click on the src folder, select New > Class, name your class, and
check the box for a main method if needed.
 Write Code: In the editor, write your code. Eclipse provides features like
syntax highlighting and auto-completion.
 Run Your Program: Right-click your Java file and select Run As > Java
Application. Output will appear in the Console view.
 Debugging: Set breakpoints by clicking in the margin, then right-click your file and select
Debug As > Java Application to debug your code.

 Use Version Control: Access Git features via Window > Show View > Git Repositories
to manage version control.
Add Plugins: Go to Help > Eclipse Marketplace to install additional plugins for languages and tools

 Explore Perspectives: Switch perspectives (e.g., Java, Debug) using the icons in the top-
right corner for different tool layouts.

4. What is GitHub:

GitHub is a web-based platform that provides version control and collaboration

features for software development projects. It uses Git, a distributed version control system, to track
changes in code and manage projects. Here are some key aspects of GitHub:
  Version Control
GitHub allows developers to manage changes to their code over time,
enabling them to track modifications, revert to previous versions, and collaborate
effectively with others. Each change is recorded in a repository, which acts as a project’s
central hub.

 Repositories
A repository (or "repo") is where all the project files and their revision history
are stored. Repositories can be public (open to everyone) or private (accessible only to specific
users).

 Collaboration Features
GitHub provides tools for collaboration, including:

o Pull Requests: A feature that allows developers to propose changes to a project.

Other team members can review the changes, discuss them, and merge them into the
main branch.
o Issues: Users can track bugs, enhancements, and other project-related tasks through
a structured issue management system.
o Projects: GitHub Projects help organize work with kanban-style boards for better
task management.

 Branching and Merging

GitHub allows users to create branches, enabling them to work on new features or
fixes independently from the main codebase. Once the work is complete, branches can be
merged back into the main branch.

 Continuous Integration/Continuous Deployment (CI/CD)

GitHub integrates with various CI/CD tools, allowing developers to automate testing and
deployment processes whenever code changes are made.

5. Why GitHub:
 Collaboration
GitHub facilitates collaboration among team members by providing tools like pull
equests, issues, and project boards. These features enable developers to propose changes, review
code, and discuss project-related tasks in a structured way, improving communication and teamwork.
  Security Features
GitHub provides various security features, including vulnerability alerts, dependency
scanning, and role-based access control, helping teams manage security risks associated with
their projects.

 Integration with Other Tools

GitHub integrates seamlessly with numerous development tools, services, and applications,
allowing teams to create custom workflows that suit their needs. This includes integration with
popular IDEs, project management tools, and cloud services.

 Github Pages
GitHub allows users to host static websites directly from their repositories through GitHub
Pages, making it easy for developers to showcase their projects or create documentation.

 GitHub Actions
This feature provides automation capabilities directly in GitHub, allowing developers to create
workflows that can automate testing, building, and deployment processes based on specific
triggers.

6. How to use GitHub:

 Sign Up: Create an account at GitHub.com.

 Install Git: Download and install Git.

 Set Up Git: Configure your username and email

 Create a Repository: Click New repository on GitHub.

 Clone Repository

 Make Changes: Edit files locally.

 Stage Changes
 Commit Changes

 Push Changes: Upload to GitHub.

 Create Pull Request: On GitHub, go to Pull Requests and click New Pull Request.

 Track Issues: Use the Issues tab for bugs and tasks.

7. What is Jenkins:

Jenkins is an open-source automation server widely used for continuous integration (CI)
and continuous delivery (CD) in software development. It helps developers automate various stages
of the software development lifecycle, including building, testing, and deploying applications. Here
are some key features and aspects of Jenkins:

1. Continuous Integration/Continuous Delivery (CI/CD)

Jenkins enables teams to integrate code changes frequently, automate testing, and deploy
applications automatically, promoting a DevOps culture and improving software quality.

2. Plugins
Jenkins has a rich ecosystem of plugins that extend its functionality. There are thousands of
plugins available to integrate with various tools and technologies, including version control
systems (like Git), build tools (like Maven), and cloud platforms.

3. Pipeline as Code
Jenkins supports defining build processes using a domain-specific language (DSL) called
Pipeline. This allows developers to create complex workflows as code, which can be
versioned and reused.

4. Distributed Builds
Jenkins can distribute the workload across multiple machines, allowing parallel execution of
builds and tests, which helps reduce overall build time.
5. User-Friendly Interface
Jenkins provides a web-based interface for configuring jobs, monitoring builds, and viewing
reports, making it accessible for both developers and project managers.

6. Community Support
Jenkins has a large, active community, providing extensive documentation, forums, and
resources to help users troubleshoot and improve their CI/CD pipelines.

7. Security Features
Jenkins offers various security features, including role-based access control, allowing teams to
manage permissions and protect sensitive information.

8. Why Jenkins:
Here are several reasons why organizations and developers choose Jenkins for
continuous integration and continuous delivery (CI/CD):

1. Automation of Builds and Tests

Jenkins automates the entire build process, allowing teams to continuously integrate and test
their code changes. This reduces the risk of errors and ensures that the codebase remains
stable.

2. Extensive Plugin Ecosystem

Jenkins has a vast library of plugins (over 1,800) that allow for integration with a wide range
of tools and technologies, including version control systems, build tools, testing
frameworks, and deployment platforms. This extensibility makes it adaptable to various
project needs.

3. Pipeline as Code
Jenkins supports defining CI/CD pipelines as code using the Pipeline DSL. This
approach allows teams to version control their build and deployment processes, making
it easier to manage and replicate across different environments.

4. Continuous Integration and Delivery

Jenkins facilitates continuous integration and delivery, allowing teams to frequently merge
code changes and deploy them to production. This results in faster feedback loops and
improved software quality.
5. Scalability
Jenkins can distribute builds across multiple machines (agents), enabling parallel execution of
jobs. This scalability helps handle larger workloads and reduces overall build times.

6. Integration with Various Tools

Jenkins can integrate seamlessly with numerous tools, including Git, Maven, Docker,
Kubernetes, and cloud services like AWS, making it a versatile choice for diverse
development environments.

9. How to use Jenkins:

Here's a brief guide on how to use Jenkins:

1. Install Jenkins

Download from the Jenkins website and follow the installation instructions for your OS.

2. Start Jenkins

Open a web browser and go to http://localhost:8080to access the Jenkins dashboard.

3. Unlock Jenkins

Use the initial admin password found in the specified location (e.g.,
/var/lib/jenkins/secrets/initialAdminPassword).

4. Install Plugins

Choose to install suggested plugins or select specific ones based on your needs.

5. Create a Job

Click New Item, enter a name, select a project type (Freestyle or Pipeline), and click OK.
6. Configure Source Code Management

Specify your source code repository (e.g., Git) and provide the necessary credentials.

7. Add Build Steps

Define build steps (e.g., run a script or execute a shell command).

8. Set Build Triggers

Configure triggers for automatic builds (e.g., poll SCM or build on code changes).

9. Save and Build

Click Save and then Build Now to run your job.

10. Monitor Results

Check build results and console output in the Build History.

Optional: Create Pipelines

For complex workflows, create a Pipeline job and define your stages using a Jenkinsfile.
SOURCE CODE

package com.devops; import javax.swing.*; import java.awt.*; import

java.awt.event.ActionEvent; import java.awt.event.ActionListener;

import java.util.ArrayList; public class devops { // List to hold

expenses private static ArrayList<Expense> expenses = new

ArrayList<>(); public static void main(String[] args) {

// Create the main frame

JFrame frame = new JFrame("Personal Expense Tracker"); frame.setSize(400,

400); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

frame.setLayout(new BorderLayout());

// Panel to hold input fields and buttons JPanel inputPanel = new JPanel();

inputPanel.setLayout(new GridLayout(4, 2, 10, 10)); // 4 rows, 2 columns with gaps

// Label for expense amount

JLabel amountLabel = new JLabel("Amount:"); inputPanel.add(amountLabel);

// Text field for amount

JTextField amountTextField = new JTextField(20); inputPanel.add(amountTextField);

// Label for category

JLabel categoryLabel = new JLabel("Category:"); inputPanel.add(categoryLabel);

// Text field for category

JTextField categoryTextField = new JTextField(20); inputPanel.add(categoryTextField);

// Label for description

JLabel descriptionLabel = new JLabel("Description:"); inputPanel.add(descriptionLabel);

// Text field for description

JTextField descriptionTextField = new JTextField(20); inputPanel.add(descriptionTextField);

// Button to add expense

 JButton addButton = new JButton("Add Expense"); inputPanel.add(addButton);

// Button to delete the last expense

JButton deleteButton = new JButton("Delete Last Expense"); inputPanel.add(deleteButton);

// Text area to display expenses

JTextArea expenseArea = new JTextArea(); expenseArea.setEditable(false);

JScrollPane scrollPane = new JScrollPane(expenseArea); // To add scroll bar frame.add(scrollPane,

BorderLayout.CENTER);

// Panel for total and expense display area

JPanel bottomPanel = new JPanel();

bottomPanel.setLayout(new BorderLayout());

// Label to display total expenses

JLabel totalLabel = new JLabel("Total: $0.00"); bottomPanel.add(totalLabel,

BorderLayout.EAST); frame.add(inputPanel, BorderLayout.NORTH);

frame.add(bottomPanel, BorderLayout.SOUTH);

// ActionListener for the Add button

addButton.addActionListener(new ActionListener() { public void

actionPerformed(ActionEvent e) {

try {

double amount = Double.parseDouble(amountTextField.getText());

String category = categoryTextField.getText();

String description = descriptionTextField.getText();

// Add expense to the list expenses.add(new

Expense(amount, category, description));

amountTextField.setText(""); // Clear input fields

categoryTextField.setText(""); descriptionTextField.setText("");

updateExpenseArea(expenseArea); updateTotalLabel(totalLabel);

} catch (NumberFormatException ex)

{ JOptionPane.showMessageDialog(frame, "Invalid amount

entered.");

});

// ActionListener for the Delete button deleteButton.addActionListener(new ActionListener() {

public

void actionPerformed(ActionEvent e) { if (!expenses.isEmpty())

{ expenses.remove(expenses.size() - 1); // Remove the last expense

updateExpenseArea(expenseArea); updateTotalLabel(totalLabel);

});

// Set frame visibility frame.setVisible(true);

// Method to update the expenses displayed in the text area private

static void updateExpenseArea(JTextArea expenseArea) {

StringBuilder expenseText = new StringBuilder(); for (Expense

expense : expenses) { expenseText.append(expense).append("\n");

expenseArea.setText(expenseText.toString());

}
 // Method to update the total expenses displayed private

static void updateTotalLabel(JLabel totalLabel) { double total

= 0; for (Expense expense : expenses) {

total += expense.getAmount();

totalLabel.setText(String.format("Total: $%.2f", total));

// Expense class to hold individual expense details class Expense { private

double amount; private String category; private String description; public

Expense(double amount, String category, String description) {

this.amount

= amount; this.category = category; this.description = description;

public double getAmount() { return

amount;

public String toString() { return String.format("$%.2f - %s: %s", amount,

category, description);

}
12. Steps and screenshots:

1. Creating java project in Eclipse:

Open Eclipse -> File -> New -> Java Project -> Project Name -> Finish

2. Create package:

R. click -> New -> Package -> Name: com.lbrce.devops -> Finish

3. Create class:

R. click -> New -> class -> class name -> DevopsProject ->Finish
4. Execute the code:
5. Create Repository: + -> New Repository -> Repository Name -> Create Repository

6. Create Token:
Settings -> Developer settings -> create tokens -> Name: demo -> select repo -> the token will be
created.
7. Push the project to github:
R. click on project -> Team -> share project -> create -> Repository -> Devops project -> Finish -> select
project -> Finish.
8. R. click on project -> Team -> Add to Index -> commit -> commit & push -> ok.
9. R. click on project -> Team -> commit -> push Head -> protocol: https -> URL : copy the github path -
>Authentication : user: poornima -> password: ……. -> preview -> preview ->user: Poornima -
> password: …… -> Login -> user: poornima -> password : Token ->Login -> push -> user: Poornima -
>password: Token -> Login -> close.
10. R. click on project -> Team -> commit -> push Head -> protocol: https -> URL : copy the github path
->Authentication : user: poornima -> password: ……. -> preview -> preview ->user: Poornima
-> password: …… -> Login -> user: poornima -> password : Token ->Login -> push -> user: Poornima -
>password: Token -> Login -> close.
10. Open github and add jenkinsfile:
pipeline { agent any st

ages {
stage('Build_stage')
{
steps
{

echo 'Building project…'

}
}
stage('Deploy_stage')
{
steps
{
echo 'Deploy project…'
}
}
stage('Test_stage')
 {
steps

{
echo 'Test project…'

}
}
}
}
11. Create jobs in CICD pipeline:

1. click on Dashboard -> Click on new item -> Enter item name: examplebuild -> click on freestyleproject -
> ok -> Description: build demo ->build steps -> Add build steps -> we have to select “Execute windows batch
command” -> echo “ my build demo” -> click on apply & save -> build now

2. click on Dashboard -> Click on new item -> Enter item name: exampledeploy -> click on freestyleproject -
> ok -> Description: deploy demo ->build steps -> Add build steps -> we have
to select “Execute windows batch command” -> echo “ my deploy demo” -> click on apply & save -> build
now

3. click on Dashboard -> Click on new item -> Enter item name: exampletest-> click on freestyleproject -> ok -
> Description: test demo ->build steps -> Add build steps -> we have to select “Execute windows batch
command” -> echo “ my test demo” -> click on apply & save -> build now
4. click on Dashboard -> Click on new item -> Enter item name: examplerelease-> click on
freestyleproject -> ok -> Description: release demo ->build steps -> Add build steps -> we have to select
“Execute windows batch command” -> echo “ my release demo” -> click on apply & save -> build now

12. To construct Declarative pipeline:

Click on new item -> Name : Devops project -> select pipeline -> ok
13. Go to the home page of the github -> go to devopsfinalproject repository -> click on code and drop down -
> copy the https url code

14. open Jenkins tool -> Dashboard -> click on Devopsproject -> pipeline -> Definition -> pipeline script from
scm -> scm -> git -> Repositories -> Repository url -> paste the url copied from the git -> Branches to build -
> */master -> apply & save -> Build now.
13. Conclusion:
In conclusion, a personal Expense Tracker is an essential tool for
individuals looking to take control of their finances. By tracking and categorizing
expenses, setting budgets, and monitoring spending patterns, users can make informed
financial decisions, avoid unnecessary debt, and save more effectively. The ease of
accessing insights into one’s financial habits empowers users to adjust their behaviour in
real time, fostering better financial health. Whether it’s for planning, saving, or simply
understanding spending habits, a personal Expense Tracker serves as a practical,
userfriendly solution for anyone aiming to manage their finances more responsibly and
achieve financial goals.

14. References:
• https://www.javatpoint.com/jenkins
• https://www.geeksforgeeks.org/what-is-ci-cd/
• https://www.geeksforgeeks.org/devops-lifecycle/