CI/CD Pipeline for Web Applications

Abstract

Modern organisation’s rapid pace of software development necessitates teams delivering high-quality software products faster than ever before. In order to accomplish this, software development teams are incorporating continuous integration and continuous deployment (CI/CD) methodologies into their software development processes. CI/CD pipelines are a set of practises and tools that allow teams to efficiently and reliably automate the development, testing, and deployment of software products. CI/CD pipelines have become an essential tool for teams delivering web applications at a faster pace while ensuring scalability, security, and performance in the context of web applications. This paper provides an overview of the best practises and tools for constructing a successful CI/CD pipeline for web applications. Version control, continuous integration, automated testing, deployment automation, monitoring, and logging are among the key steps covered in the paper. The paper also discusses the advantages and disadvantages of CI/CD pipelines, such as increased productivity, shorter time-to-market, fewer manual errors, and better collaboration between development and operations teams. Several case studies are included in the paper to demonstrate the effectiveness of CI/CD pipelines in web application development. The case studies cover a variety of web applications, such as e-commerce websites, social media platforms, and healthcare apps. Each case study provides practical insights into CI/CD pipeline implementation, including the tools and technologies used, the benefits realised, and the challenges encountered. The case studies also emphasise the importance of culture and collaboration in CI/CD pipeline implementation success. The paper also discusses the key tools and technologies used in web application CI/CD pipelines, such as Git, Jenkins, Docker, Kubernetes, and AWS. The paper provides an overview of these tools as well as their role in various stages of the CI/CD pipeline. The paper also discusses the importance of security in CI/CD pipelines, as well as an overview of the key security practices that must be implemented.

Introduction

I. INTRODUCTION

A. Introduction

The CI/CD Pipeline (Continuous Integration/Continuous Deployment) methodology involves the automation of software delivery processes, from development to testing and deployment. This methodology aims to provide a dependable and efficient approach to software development, resulting in the delivery of high-quality software products in a shorter period of time. A CI/CD pipeline for web applications is designed to automate the entire software development lifecycle, from code changes to deployment, ensuring that code is consistently tested, built, and deployed. A CI/CD pipeline (Continuous Integration/Continuous Deployment) is a set of automated steps designed to help web application developers deliver new code changes or updates to their applications more efficiently and with fewer errors.

The following steps are typically included in the CI/CD pipeline for web applications:

1. Code Development entails writing, testing, and committing code changes to a shared repository. Continuous Integration (CI): When code changes are committed to the repository, the CI system builds and tests the application to detect errors. After the code changes pass the initial build and test stage, the pipeline runs a series of automated tests to ensure that the application behaves as expected.
2. Continuous Deployment: Once the code changes have been tested and approved, the pipeline deploys the new version of the application to a staging environment automatically.
3. User Acceptance Testing (UAT): In the staging environment, users or testers review the new version of the application to ensure it works properly.
4. Production Deployment: Once the new version of the application is approved, it is deployed to the production environment by the pipeline.
5. Monitoring and Feedback: The pipeline monitors the performance of the application and provides feedback to the development team to help them identify and resolve issues as quickly as possible.

The CI/CD pipeline can assist developers in delivering high-quality software more quickly and with fewer bugs and errors. By automating the testing and deployment process, the risk of human error is reduced, and the time it takes to get new features and updates into production is reduced.

B. Problem Definition

The CI/CD Pipeline (Continuous Integration/Continuous Deployment) methodology involves the automation of software delivery processes, from development to testing and deployment. This methodology aims to provide a dependable and efficient approach to software development, resulting in the delivery of high-quality software products in a shorter period of time. A CI/CD pipeline for web applications is designed to automate the entire software development lifecycle, from code changes to deployment, ensuring that code is consistently tested, built, and deployed. The problem definition for a CI/CD pipeline for web applications includes the following elements: The first step in the CI/CD pipeline is to build the application and run unit and integration tests to ensure that the code is error-free and meets the acceptance criteria. The challenge is to automate this process in order to ensure consistency and repeatability. Code quality: Another critical aspect to consider when developing a CI/CD pipeline is code quality. The pipeline should include a mechanism for automatically checking code quality, such as code reviews and static analysis, to ensure that the code adheres to coding standards and best practices. Deployment: Once the code has been tested and validated, the application will be deployed to the production environment. The challenge is to automate and standardize the deployment process across multiple environments. Continuous monitoring of the application is a critical component of the CI/CD pipeline. When something goes wrong in the production environment, the pipeline should detect it and notify the team. Security: When developing web applications, security is a major concern. The CI/CD pipeline should include a mechanism for ensuring that the code is secure and free of vulnerabilities. Scalability: The CI/CD pipeline should be scalable to support the application's and team's growth. It should be adaptable enough to accommodate multiple developers working on the same codebase at the same time. Refactor frequently: The practice of refactoring involves enhancing the design of existing code without modifying its functionality. Refactoring your code on a regular basis can keep it tidy and maintainable. The challenge is to create a dependable, efficient, and automated CI/CD pipeline for web applications that reduces time-to-market, improves code quality, and ensures application security and scalability.

II. LITERATURE REVIEW

A. Existing System

Existing systems for implementing a CI/CD pipeline for web applications are numerous. Here are a couple of examples:

Jenkins: Jenkins is an open-source CI/CD automation server for building, testing, and deploying web applications. It has a large plugin ecosystem and integrations with other tools.

CircleCI: CircleCI is a cloud-based continuous integration and delivery platform that supports multiple programming languages and integrates with a variety of tools and services, including GitHub, Docker, and AWS.

Travis CI is a hosted continuous integration and delivery platform that integrates with GitHub and can be used to build, test, and deploy web applications. It supports multiple programming languages and includes Docker support.

GitLab CI/CD: GitLab CI/CD is an open-source Git-based platform for managing the software development process that is part of the GitLab platform. It has many features, such as source code management, CI/CD pipelines, and issue tracking.

AWS CodePipeline is a fully managed CI/CD service for building, testing, and deploying web applications on AWS. It works with other AWS services like AWS CodeBuild, AWS CodeDeploy, and AWS CloudFormation.

Microsoft Azure DevOps is a cloud-based platform that offers a variety of tools and services for managing the software development process, such as CI/CD pipelines, source control, and project management.

These existing systems can be customized and configured to meet the specific requirements of a web application, and they can be integrated with a variety of other tools and services to form a comprehensive CI/CD pipeline.

III. PROPOSED DESIGN

A proposed CI/CD pipeline for web applications would include several components that work together to automate the build, testing, and deployment processes. A high-level overview of a proposed system for a CI/CD pipeline for web applications is provided below:

Version Control System (VCS): To manage the codebase and track changes, a version control system such as Git would be used. Git would be used by developers to commit changes to the codebase, and Git would be used by the pipeline to retrieve the most recent version of the code.

Containerization: The application and its dependencies would be packaged into containers using Docker. The build process would produce a Docker image, which would be uploaded to a container registry like Docker Hub.

Continuous Deployment (CD) Tools: A CD tool, such as AWS CodeDeploy, would be used to automate the application's deployment across multiple environments. The CD tool would be set up to retrieve the Docker image from the container registry and deploy it to a staging environment for additional testing. The CD tool would automatically promote the image to the production environment once the application passed all tests in the staging environment.

Testing Frameworks: Testing frameworks like Selenium would be used to automate application testing. A suite of automated tests would be run during the build process and deployment to the staging environment as part of the pipeline. This ensures that any problems are identified and resolved before the application is deployed to production.

Monitoring and logging tools, such as New Relic, would be used to monitor the application's performance and provide feedback to the development team. The monitoring tools would be set up to notify the team if any problems arose in production, allowing them to quickly identify and resolve problems.

The proposed CI/CD pipeline for web applications would streamline and automate the process of developing, testing, and deploying applications. It would reduce the likelihood of errors and accelerate development and deployment, resulting in a more efficient and effective development process.

A. System Analysis and Approach

There are numerous crucial processes involved in designing and implementing a CI/CD (Continuous Integration/Continuous Deployment) pipeline for a web application. An overview of the system analysis and method for establishing such a pipeline is given below:

Define Requirements: To begin, determine the precise specifications of your web application and the results you hope to achieve with your CI/CD pipeline. Take into account elements like the target platforms, the development and deployment environments, the programming languages, frameworks, and technologies utilised, as well as any particular quality or security standards.

Version Control: Manage your source code and make sure that all changes are tracked by implementing a version control system (such as Git). Use branching and merging techniques that are compatible with your development workflow (such as GitFlow) and lay out precise rules for code review and teamwork.

Automated Build: Establish an automated build procedure that will translate your application code into deployable artefacts by assembling and packaging them. Create a build script or configuration file that lists the necessary dependencies, build steps, and other requirements (using, for instance, Maven or Gradle tools).

Creating a thorough testing approach can help you ensure the dependability and quality of your web application. End-to-end tests, integration tests, and unit tests are frequently included in this. Use testing frameworks and tools appropriate for the frameworks and programming languages you select (JUnit, Selenium, etc.). To run these tests automatically after each build, incorporate them into your CI/CD pipeline.

Creating a thorough testing approach can help you ensure the dependability and quality of your web application. End-to-end tests, integration tests, and unit tests are frequently included in this. Use testing frameworks and tools appropriate for the frameworks and programming languages you select (JUnit, Selenium, etc.). To run these tests automatically after each build, incorporate them into your CI/CD pipeline.

Automate the deployment process to guarantee dependable and error-free deployments. To automate the provisioning of infrastructure, configuration management, and the deployment of your application to the required environments (such as development, staging, and production), define deployment scripts or use deployment tools (such as Ansible, Kubernetes). Establish effective monitoring and rollback systems.

Continuous Deployment: Configure your CI/CD pipeline for continuous deployment, where successful builds are automatically delivered to particular environments, if it is appropriate for your application and organisation. This can be implemented fully or gradually (using canary deployments, for example).

Implement monitoring and logging tools (such as Prometheus or the ELK stack) to keep tabs on the performance, general health, and behaviour of your web application in real time. Setup alerts to inform pertinent parties of any potential problems or anomalies.

B. Website Architecture and Workflow

C. Hardware and Software Specification

The software specifications for a CI/CD pipeline for web applications can also vary depending on the application's specific needs and the tools used. Here are some general software recommendations, however: Version Control System (VCS): To manage the codebase and track changes, the pipeline should integrate with a VCS such as Git, SVN, or Mercurial.

Continuous Integration (CI) Server: To automate the build and test processes, the pipeline should use a CI server such as Jenkins, CircleCI, or Travis CI.

Configuration Management: To automate the setup and configuration of the pipeline's various components, the pipeline should use configuration management tools such as Ansible, Chef, or Puppet.

Containerization: Containerization tools like Docker or Kubernetes can be used to package the application and its dependencies into containers that can be easily deployed across multiple environments.

Continuous Delivery/Deployment (CD) Tools: CD tools such as AWS CodeDeploy, Octopus Deploy, or Azure DevOps can be used to automate application deployment across multiple environments.

Testing Frameworks: To automate application testing, the pipeline should include testing frameworks such as Selenium, JUnit, or pytest.

Monitoring and logging tools such as New Relic, Splunk, or the ELK stack should be used in the pipeline to monitor application performance and provide feedback to the development team.

Collaboration Tools: Communication between the various stakeholders involved in the development process can be facilitated using collaboration tools such as Slack, Microsoft Teams, or Trello.

The software specifications for a CI/CD pipeline should be carefully evaluated and chosen in accordance with the specific requirements of the web application being developed.

An essential tool for managing source code and other digital assets during software development is a version control system (VCS).

The hardware specifications for a CI/CD pipeline for web applications can vary depending on the size and complexity of the application, the number of developers working on the project, and the frequency of code changes being pushed to the pipeline. However, here are some general hardware recommendations:

CPU: At least a quad-core processor with a clock speed of 2.5 GHz or higher. A higher core count and clock speed will help the CI/CD pipeline to run builds and tests faster.

RAM: At least 8 GB of RAM, but 16 GB or more is recommended for larger applications.

Storage: At least 256 GB of solid-state drive (SSD) storage is recommended, as it can handle the read and write operations faster than traditional hard disk drives (HDD).

Network: A reliable and high-speed internet connection is necessary to ensure fast data transfer and enable seamless communication between the different components of the pipeline.

Virtualization: If the CI/CD pipeline uses virtualization technologies such as containers or virtual machines, the hardware specifications should be increased accordingly to ensure sufficient resources are available.

Scalability: The CI/CD pipeline should be designed to scale horizontally by adding more nodes to the cluster or vertically by adding more resources to the existing nodes. This will ensure that the pipeline can handle increased workloads as the application grows.

D. Methodology

The steps for implementing a CI/CD pipeline for web applications are generally as follows:

Plan and design: The pipeline's first step is to plan and design it. This includes defining the pipeline stages, identifying the requirements, selecting the tools and technologies to be used, and defining the deployment strategy.

The pipeline must be developed and tested in the second step. This includes constructing the pipeline as well as writing the necessary scripts and configurations. Testing the pipeline is also necessary to ensure that it is operational and meets the requirements.

Integrate and automate: The pipeline must be integrated and automated in the third step. This entails connecting the pipeline to the source code management system, automating the build, test, and deployment processes, and ensuring the pipeline's robustness and scalability.

Deploy and monitor: The fourth step is to deploy and monitor the pipeline's performance. This includes putting the pipeline into production, monitoring it for errors or failures, and fine-tuning it as needed.

The final step is to improve the pipeline on a continuous basis. This includes monitoring the pipeline's performance, gathering user feedback, and improving the pipeline based on the feedback.

Implementing a CI/CD pipeline for web applications should be done in an iterative and incremental manner. Before moving on to the next iteration, each iteration should focus on delivering a small set of features or improvements that can be tested and validated. The pipeline should also be monitored and improved on a regular basis to ensure that it is meeting the needs of the users and the organization.

IV. RESULTS AND LIMITATIONS

Faster Time-to-Market: By automating the build, testing, and deployment processes, CI/CD makes it possible to bring features and bug fixes to production more quickly. Developers may concentrate on writing code while the pipeline handles monotonous chores, which reduces manual labour and quickens the release cycle.

Continuous Integration (CI) is the practise of developers routinely merging their changes into a shared repository, which starts automated builds and tests. As a result, conflicts are promptly identified and code updates are regularly implemented. A more stable codebase results from continuous integration's assistance in quickly identifying and resolving integration problems.

Early Bug Detection: The CI/CD pipeline includes automated testing, such as unit tests, integration tests, and end-to-end tests. Testing every update to the code helps find problems and issues early, enhancing the quality of the product.

Collaboration among developers, testers, and operations teams is improved thanks to CI/CD. Developers can work on several additions or fixes at once using version control, and teams can evaluate code changes and offer input. This teamwork improves communication and makes sure that everyone is striving to provide a trustworthy online application.

Deployment Reliability: The pipeline's CD component offers automation that makes deployments consistent and repeatable. The application is deployed in a known state and deployments are carried out in a controlled and standardised manner, minimising the possibility of human mistake.

Rollback and Scalability: CI/CD pipelines can incorporate mechanisms for scaling, such as infrastructure autoscaling or container orchestration. As a result, the programme can easily accommodate an increase in traffic or demand. Additionally, swift rollbacks or roll forwards to earlier stable versions can be readily carried out in the event that a problem occurs in the production environment.

DevOps Culture: CI/CD pipelines help development teams adopt a DevOps culture. Key components of DevOps include teamwork, automation, and an emphasis on providing value to end users. By encouraging tight collaboration between developers, testers, and operations, a CI/CD pipeline may create cross-functional skills and shared accountability.

While CI/CD pipelines have many advantages, there are some restrictions and difficulties that businesses should be aware of:

Learning Curve and Initial Setup: For companies unfamiliar with the idea, setting up and configuring a CI/CD pipeline can be challenging. It necessitates learning and implementing fresh techniques, procedures, and best practises. Initial setup time and the learning curve may impede down progress.

Complexity of the Infrastructure: Managing the infrastructure necessary for a CI/CD pipeline can be difficult. Servers, build agents, test environments, and deployment targets must all be installed and maintained. To properly manage and scale the infrastructure, organisations must invest the necessary funds and personnel.

Test Coverage and Environment Parity: Maintaining environment parity throughout the pipeline's many stages (development, staging, and production) can be difficult. To identify problems that might only arise in particular configurations, it is crucial to have realistic test environments that closely resemble the production environment.

Maintenance and Tool Compatibility: Updating the CI/CD pipeline requires continual work as technologies and tools advance. Maintaining the pipeline with the most recent versions, dependencies, and assuring tool compatibility can take time and call for constant monitoring and upgrades.

Legacy Systems and Dependencies: It can be difficult to integrate a CI/CD pipeline with legacy systems or apps that have complicated dependencies. Older software could have flaws that make automation difficult and require extra workarounds.

Security and Compliance: Even while CI/CD pipelines allow for quicker and more frequent deployments, security and compliance issues must still be taken into account. To make sure that applications adhere to the relevant standards and do not pose security concerns, it is essential to incorporate security testing, vulnerability scanning, and compliance checks into the pipeline.

Cost and Resource Management: Upkeep and expansion of a CI/CD pipeline's infrastructure can be expensive, particularly for large-scale applications or businesses with a high level of development activity. To effectively limit expenses, resource management and optimisation must be done well.

Adoption of the CI/CD method by the team necessitates a cultural shift as well as their collective collaboration. It might call for adjustments to workflow, teamwork procedures, and mindset. It may be difficult for some team members to adjust to the new procedures and methods of operation.

False Positives and Negatives: Automated testing in a CI/CD pipeline occasionally results in false positives (problems that are not actually there) or false negatives (problems that are not actually present).

Conclusion

Continuous Integration/Continuous Deployment (CI/CD) is a development methodology that allows developers to automate the process of creating, testing, and deploying software applications. The CI/CD pipeline is a collection of automated processes that assist developers in ensuring that code changes are constantly tested and integrated into the application without errors or issues. In the world of software development, CI/CD is becoming increasingly popular, particularly for web applications. This is because web applications are typically more complex than other types of software applications, necessitating more testing and integration to ensure proper operation. This article will go over the CI/CD pipeline for web applications and how it can help developers. A. The Web Application CI/CD Pipeline The CI/CD pipeline for web applications is divided into several stages that developers must complete in order to ensure that their applications are continuously integrated, tested, and deployed. The main stages of the CI/CD pipeline for web applications are as follows: B. Commit Code The code commit stage is the first stage in the CI/CD pipeline for web applications. Developers commit their changes to a code repository, such as GitHub or Bitbucket, at this stage. The code repository serves as a hub for developers to collaborate and share code changes. C. Construction Stage The build stage is the second stage in the CI/CD pipeline for web applications. During this stage, the source code is compiled and a deployable artefact is created. The build process should be automated and started by the code commit stage. D. Stage of Testing The test stage is the third stage in the CI/CD pipeline for web applications. This stage entails testing the code changes to ensure that no bugs or issues are introduced. This stage allows for the execution of a variety of tests, including unit tests, integration tests, and acceptance tests. E. Stage of Deployment The deploy stage is the fourth stage in the CI/CD pipeline for web applications. At this stage, the code changes are deployed to the production environment. The deployment process should be automated and initiated by the successful completion of the test stage. F. The Advantages of a CI/CD Pipeline for Web Applications Using a CI/CD pipeline for web applications has several advantages, including: G. Reduced Time to Market The web application CI/CD pipeline enables developers to release new features and updates more frequently, reducing time-to-market. This leads to increased customer satisfaction and revenue for the company. H. Better Quality The CI/CD pipeline\'s automated testing ensures that any issues or bugs are discovered early in the development process. This results in higher-quality software and lowers the likelihood of errors and downtime. I. Improved Collaboration The code repository and automated processes in the CI/CD pipeline encourage developer collaboration, allowing them to collaborate more efficiently and effectively J. Increased Agility The CI/CD pipeline for web applications enables developers to respond quickly to market, customer, and business requirements changes. This allows businesses to stay competitive and adapt to changing conditions. Finally, the CI/CD pipeline for web applications is a must-have tool for developers looking to improve their software development process. Developers can ensure that their applications are of high quality, released faster, and more responsive to changing requirements by automating the building, testing, and deployment processes. A CI/CD pipeline for web applications has numerous advantages, and it is a tool that all developers should consider using to improve their software development process. Future research can concentrate on a number of areas to develop and optimise CI/CD pipelines because the field of CI/CD for web apps is continually changing. Here are some probable directions for the future: Infrastructure as Code (IaC): Improve the CI/CD pipeline\'s ability to integrate infrastructure provisioning and management technologies like Terraform or AWS CloudFormation. This makes it simpler to design and manage development, staging, and production environments by enabling uniform and repeatable infrastructure configurations. Streamline application deployment, scalability, and portability by utilising containerization and orchestration technologies like Docker and container orchestration platforms like Kubernetes. Application packaging and deployment across many environments can be made more effective and consistent by integrating containerization into the CI/CD workflow. Progressive Delivery: Use progressive delivery strategies to gradually roll out new features or adjustments to production settings. These strategies include blue-green deployments, canary releases, and feature flags. This strategy reduces the danger of deploying modifications while enabling speedy rollbacks in the event of problems. Monitoring of the Infrastructure and Application: To provide better insights into the performance and general health of the Infrastructure and Application, the CI/CD pipeline\'s monitoring capabilities should be improved. Utilise software such as Prometheus, Grafana, or Datadog to visualise data, monitor metrics, and produce alerts depending on preset thresholds. Security Testing: By incorporating security testing tools and procedures, the CI/CD pipeline\'s security features will be strengthened. Static code analysis, vulnerability scanning, dependency analysis, and frameworks for security testing are included in this. By automating security testing, it is made sure that flaws and vulnerabilities are found early in the development process. Continuous Feedback and Metrics: By collecting and analysing pertinent metrics, such as build times, test coverage, deployment success rate, and customer feedback, the CI/CD pipeline may be made to have a more effective feedback loop. These measurements can aid in locating bottlenecks, enhancing functionality, and increasing the pipeline\'s effectiveness. Integrate the CI/CD pipeline with the necessary compliance and governance needs. In order to make sure that security and regulatory requirements are satisfied during the development and deployment process, automated checks and controls must be put in place. Examine the use of machine learning and artificial intelligence (AI) approaches to automate and improve some components of the CI/CD process. Predictive analysis for release planning and risk assessment, for instance, or intelligent test case selection, anomaly detection in metrics and logs, etc. Investigate the CI/CD pipeline\'s potential integration of serverless computing platforms, such as AWS Lambda or Azure Functions. Serverless designs can streamline deployment and scalability, lessen the administrative burden of managing infrastructure, and facilitate cost reduction. cooperation and Communication: By including technologies like Slack, Microsoft Teams, or Jira into the CI/CD pipeline, you may improve cooperation and communication between development, testing, operations, and other stakeholders. This enhances transparency, makes it easier to provide input, and speeds the development process as a whole. These future directions emphasise areas where improvements can be made to enhance the overall software development lifecycle, further optimise CI/CD pipelines, and increase efficiency. Before implementing new technology or strategies, it\'s crucial to consider your organization\'s unique demands and limitations.

References

[1] Duvall, P., Matyas, S., & Glover, A. (2007). Continuous integration: improving software quality and reducing risk. Pearson Education. [2] Fowler, M. (2006). Continuous integration. Martin Fowler Website. Retrieved from https://martinfowler.com/articles/continuousIntegration.html [3] Srinivasan, J., Palaniappan, R., & Kanmani, S. (2019). Implementing CI/CD pipeline using Jenkins for web application development. In 2019 IEEE International Conference on System, Computation, Automation and Networking (ICSCAN) (pp. 1-6). IEEE. [4] Reynolds, R. (2016). Continuous deployment with Jenkins: Build and deploy web-scale applications on a distributed system using Jenkins. Packt Publishing Ltd. [5] Shahin, M. I., Jamous, A. F., Almugrin, A. A., & Aborizka, M. (2017). An effective cloud-based continuous integration and delivery platform for web applications. In 2017 International Conference on Engineering & MIS (ICEMIS) (pp. 1-5). IEEE. [6] Kucherenko, V., Babenko, V., & Ruban, O. (2019). Implementation of CI/CD pipeline for web application development using GitLab CI. In 2019 IEEE 39th International Conference on Electronics and Nanotechnology (ELNANO) (pp. 1-4). IEEE. [7] Hassan, S. U., & Lago, P. (2015). An empirical study on the impact of Continuous Integration on software quality. IEEE Transactions on Software Engineering, 42(4), 356-377. [8] Kim, G., Kwon, Y., Kim, S., & Yang, J. (2018). A review of continuous integration and deployment for web applications. In 2018 International Conference on Platform Technology and Service (PlatCon) (pp. 1-4). IEEE. [9] Hasan, M. M., Wasi-ur-Rahman, M., & Altman, A. (2019). DevOps-based software development life cycle for continuous integration and deployment of web applications. In 2019 International Conference on Electrical, Computer and Communication Engineering (ECCE) (pp. 1-6). IEEE. [10] Shalaginov, A., Afanaseva, I., & Tyurina, Y. (2020). CI/CD pipeline optimization for web development. In 2020 International Conference on Industrial Engineering, Applications and Manufacturing (ICIEAM) (pp. 1-4). IEEE. [11] Shaikh, R., Sheikh, M., & Kakade, N. (2019). Continuous integration and delivery pipeline for web application using Jenkins. In 2019 2nd International Conference on Intelligent Computing, Instrumentation and Control Technologies (ICICICT) (pp. 1102-1106). IEEE. [12] Chou, C. T., Chou, Y. Y., Chen, C. Y., & Chang, C. J. (2019). A web-based continuous integration and deployment pipeline. In 2019 International Conference on Applied System Innovation (ICASI) (pp. 1-5). IEEE. [13] Budhathoki, R., Pandey, S., Poudel, B. N., & Regmi, R. (2020). Continuous integration and deployment pipeline for web application development. In 2020 International Conference on Information Management and Technology (ICIMTech) (pp. 1-6). IEEE. [14] Yadav, R., Saxena, K., Agrawal, A., & Tiwari, A. (2020). CI/CD pipeline implementation for web application using Jenkins. In 2020 11th International Conference on Computing, Communication and Networking Technologies (ICCCNT) (pp. 1-4). IEEE. [15] Neumann, P. G., Söldner, F., Kerkow, D., & Gorschek, T. (2016). CI/CD automation: a systematic literature review. Journal of Software: Evolution and Process, 28(12), 1019-1059.

Copyright

Copyright © 2023 Nikhil Singh, Durgesh Patel, Ankit Raj, Shubham , Ms. Sukhmeet Kaur. This is an open access article distributed under the Creative Commons Attribution License, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.