done: issue#148 - Jenkins

Deployment/DevOps/README.md

@@ -0,0 +1,4 @@
+# DevOps
+
+- [Life Cycle of DevOps](./life_cycle.md)
+- [Phases of the DevOps Lifecycle](./phases_of_life_cycle.md)

Deployment/DevOps/life_cycle.md

@@ -0,0 +1,27 @@
+# DevOps Life Cycle
+DevOps is a practice that enables a single team to handle the whole application lifecycle, including development, testing, release, deployment, operation, display, and planning. It is a mix of the terms “Dev” (for development) and “Ops” (for operations).
+
+DevOps Lifecycle is the set of phases that includes DevOps for taking part in Development and Operation group duties for quicker software program delivery. DevOps follows positive techniques that consist of code, building, testing, releasing, deploying, operating, displaying, and planning. DevOps lifecycle follows a range of phases such as non-stop development, non-stop integration, non-stop testing, non-stop monitoring, and non-stop feedback.
+
+## 7 Cs of DevOps 
+1. **Continuous Development**: In Continuous Development code is written in small, continuous bits rather than all at once, Continuous Development is important in DevOps because this improves efficiency every time a piece of code is created, it is tested, built, and deployed into production.
+
+2. **Continuous Integration**: Continuous Integration can be explained mainly in 4 stages in DevOps. They are as follows:
+    1. Getting the SourceCode from SCM (Source Code Management) (ex. Github is one of the most popular tool)
+    2. Building the code (ex. Maven can build code into the required packages like war, jar ear etc)
+    3. Code quality review (ex. SonarQube can perform code quality review where it will generate report of code quality)
+    4. Storing the build artifacts 
+
+3. **Continuous Testing**: We can deploy  continuous testing with the use of the agile and DevOps methodologies. Depending on our needs, we can perform continuous testing using automation testing tools such as Testsigma, Selenium, LambdaTest, etc.
+
+4. **Continuous Deployment/Continuous Delivery**:
+
+    ***Continuous Deployment:*** Continuous Deployment is the process of automatically deploying an application into the production environment when it has completed testing and the build stages. Here, we’ll automate everything from obtaining the application’s source code to deploying it.
+
+    ***Continuous Delivery:*** Continuous Delivery is the process of deploying an application into production servers manually when it has completed testing and the build stages. Here, we’ll automate the continuous integration processes, however, manual involvement is still required for deploying it to the production environment.
+
+5. **Continuous Monitoring**: DevOps lifecycle is incomplete if there was no Continuous Monitoring. Continuous Monitoring can be achieved with the help of Prometheus and Grafana we can continuously monitor and can get notified before anything goes wrong with the help of Prometheus we can gather many performance measures, including CPU and memory utilization, network traffic, application response times, error rates, and others. Grafana makes it possible to visually represent and keep track of data from time series, such as CPU and memory utilization.
+
+6. **Continuous Feedback**: Continuous Feedback can increase the performance of the application and reduce bugs in the code making it smooth for end users to use the application.
+
+7. **Continuous Operations**: More output, lower manufacturing costs, and better quality control are benefits of continuous operations.

Deployment/DevOps/phases_of_life_cycle.md

@@ -0,0 +1,17 @@
+# Phases of Life Cycle
+
+1. **Plan**: Professionals determine the commercial need and gather end-user opinions throughout this level. In this step, they design a project plan to optimize business impact and produce the intended result.
+
+2. **Code** – During this point, the code is being developed. To simplify the design process, the developer team employs lifecycle DevOps tools and extensions like Git that assist them in preventing safety problems and bad coding standards.
+
+3. **Build** – After programmers have completed their tasks, they use tools such as Maven and Gradle to submit the code to the common code source. 
+
+4. **Test** – To assure software integrity, the product is first delivered to the test platform to execute various sorts of screening such as user acceptability testing, safety testing, integration checking, speed testing, and so on, utilizing tools such as JUnit, Selenium, etc. 
+
+5. **Release** – At this point, the build is prepared to be deployed in the operational environment. The DevOps department prepares updates or sends several versions to production when the build satisfies all checks based on the organizational demands.
+
+6. **Deploy** – At this point, Infrastructure-as-Code assists in creating the operational infrastructure and subsequently publishes the build using various DevOps lifecycle tools.
+
+7. **Operate** – This version is now convenient for users to utilize. With tools including Chef, the management department take care of server configuration and deployment at this point. 
+
+8. **Monitor** – The DevOps workflow is observed at this level depending on data gathered from consumer behavior, application efficiency, and other sources. The ability to observe the complete surroundings aids teams in identifying bottlenecks affecting the production and operations teams’ performance. 

Deployment/README.md

@@ -1,6 +1,8 @@
 # Deployement
 
+- [DevOps](./DevOps/README.md)
 - [nginx](./nginx.md)
+- [Jenkins](./jenkins/README.md)
 - [Prepare Ubuntu Server](./prepare_server.md)
 - [Deploy node.js Frontend applicatoin on Ubuntu](./deploy_node_frontend_on_ubuntu.md)
 - [Deploy Django Backend project on Ubuntu](./deploy_django_backend_on_ubuntu.md)

Deployment/jenkins/README.md

@@ -0,0 +1,17 @@
+# Jenkins
+Jenkins is a open source automation server which can automate the building, testing and deployment of the application to different servers like deployment, testing and production. Jenkins is primarily used for the continuous integration (CI) and continuous deployment (CD) pipelines.
+
+## What is Jenkins?
+Jenkins is a hub for automating the various aspects of the software development lifecycle which includes building, testing, and deploying the application. We can call Jenkins a pipeline orchestrator where the developer can manage the pipelines of the projects that they have been developed.
+
+## Why Jenkins?
+- **Master CI/CD Pipelines**: Automate building, testing and deploying code efficiently.
+- **In-Demand DevOps Skill**: Jenkins knowledge is valuable for roles like DevOps and Build Engineers.
+- **Automate Repetitive Tasks**: Save time and reduce human error in software development.
+- **Wild Tool Integration**: Works with numerous tools like Git, Maven, Docker, and Kubernets.
+- **Boost Team Collaboration**
+- **Scalability**: Supports large scale projects with distributed builds.
+- **Career growth**
+
+## Table of Contents
+- [Prerequisites](./prerequisites.md)

Deployment/jenkins/prerequisites.md

@@ -0,0 +1,6 @@
+# Prerequisites
+To effectively implement continuous integration, continuous deployment, and testing using Jenkins, it's essential to have a solid understanding of the following fundamentals:
+
+- [DevOps Life Cycle](../DevOps/life_cycle.md)
+- [Software Development Life Cycle](../../SoftwareDevelopment/sdlc.md)
+- [Primary Use of Jenkins in DevOps](./primary_use.md)

Deployment/jenkins/primary_use.md

@@ -0,0 +1,34 @@
+# Primary Uses of Jenkins in DevOps
+Jenkins is a versatile open-source software that provides an automation server that helps automate repetitive tasks within the process of software development. It not only supports the construction, testing, and optimization processes of applications but also automates the entire procedure from code commit to production deployment.
+
+1. `Continuous Integration (CI)`: Jenkins's main purpose is to automate the CI process, in which it combines multiple contributors code changes into a common repo. It keeps tracking version control systems as new commits are submitted, triggers build tasks, executes automated tests, and provides code quality checking and stability appearance in real-time.
+
+2. `Continuous Delivery (CD)`: Jenkins XML goes beyond CI, which means that it is not just for the process of continuous delivery but also assists in automating the process of delivering changes to production environments reliably and efficiently. It coordinates deployment pipelines from artifact packaging to environment provisioning, performing deployment scripts, delivering updates, and deploying them fluently.
+
+3. `Automated Testing`: Jenkins teams up with different testing frameworks and tools that are used to automate the performance of unit tests, integration testing, and end-to-end testing. It arranges test cases, enables test report generation, and alerts developers to failed tests, resulting in early defect identification, and the code quality is always maintained during the development process.
+
+4. `Infrastructure as Code (IaC)`: Jenkins encourages the provisioning and configuration of infrastructure by deriving plugins and integrations within tools like Ansible, Terraform, and Chef. It enables IaC implementation where infrastructure changes are committed into a repository, tested, and deployed along with application code, consequently driving more problems in repeatability and correlation.
+
+5. `Deployment Automation`: Jenkins removes the barriers due to bottlenecks and human errors by using the deployment scripts to execute them, rolling updates, and blue-green deployments. It brings visibility into the deployment progress, logs and metrics, with teams being able to roll out changes fast and reliably with the headache of proper downtime.
+
+## Features and Benefits of Jenkins
+- Extensibility
+
+- Scalability
+
+- Flexibility
+
+- Visibility and Monitoring
+
+- Community Support
+
+## Real-World Applications of Jenkins
+- Software Development
+
+- Continuous Integration and Delivery
+
+- Release Management
+
+- Quality Assurance and Testing
+
+- Infrastructure Automation