-
Notifications
You must be signed in to change notification settings - Fork 2
DEVOPS DOCUMENTATION
The DevOps practice, integrating development and operations, revolutionizes the software development lifecycle. This project incorporated fundamental DevOps principles to optimize efficiency and quality. We will delve into each aspect in-depth, from task control to automated deployment, highlighting tool choices and adopted strategies.
JetBrains' YouTrack emerged as a robust choice for task and requirement control. The tool facilitated an agile approach, making it easy to create, assign, and trace tasks. Each task represented a specific requirement, providing a detailed view of project progress and dependencies. The continuous integration between YouTrack and the version control system established a cohesive environment for development.
Task control followed an agile methodology with short iterations and constant user feedback. Regular meetings occurred at each stage of the lifecycle to ensure tasks aligned with customer expectations. Close collaboration between the development team and the customer was essential for continuous adjustments and keeping the project customer-centric.
The integration between YouTrack and the version control system extended to ensure clear traceability between commits and requirements. Each commit was associated with a specific task, providing a granular view of implemented changes concerning project requirements. This traceability was valuable for audits, impact analysis, and understanding code evolution in response to customer requirements.
Branch management adopted the Gitflow strategy, a robust approach to organizing the workflow. The structure involved maintaining main branches like master and develop, along with feature and bugfix branches. Each feature or fix was developed in a specific branch, isolating it from the main code until completion. The strategy provided an organized development environment and facilitated code review and change incorporation.
Branch management included a rigorous code review practice. Before merging a feature or fix, a mandatory review process involving peer code review was required. This practice not only ensured code quality but also facilitated knowledge dissemination within the team. Constructive comments and discussions during reviews contributed to a culture of continuous improvement.
The Gitflow strategy, with its clear branch segregation, minimized conflicts during simultaneous feature development by different team members. Continuous integration was implemented in tandem, ensuring each feature was tested and validated before merging into the develop branch. This ensured the main code remained stable and ready for new implementations.
Continuous Integration (CI) was incorporated into the project through the GitHub Actions platform. With each push or pull request, a CI pipeline was triggered, consisting of several crucial steps. This included code compilation, execution of unit tests, static code analysis, and code coverage evaluation using Jacoco. The use of parallel jobs optimized the efficiency of the process and ensured quick issue identification.
Continuous Integration was not just a practice but a strict policy. The policy stated that no code could be merged without passing all CI pipeline checks. This ensured that only tested and validated code was incorporated into the main codebase, maintaining repository integrity and preventing regressions.
The use of CI provided immediate feedback to developers. By identifying test failures or code pattern violations, the pipeline issued instant alerts. This practice accelerated issue identification and correction, allowing for rapid iterations and an agile development cycle.
Quality assurance was intrinsic to the testing practice, and JUnit emerged as the primary framework for unit testing. Each system component was accompanied by rigorous unit tests, covering both positive and negative scenarios. The testing approach was driven by use cases, ensuring essential functionalities were validated.
Jacoco was incorporated for code coverage assessment. This critical component provided a holistic view of which parts of the code were exercised by the tests. Detailed coverage analysis allowed for identifying test gaps and directing efforts towards higher-risk areas.
The testing practice extended beyond feature development. Continuous tests were conducted as part of continuous integration, ensuring new implementations didn't introduce regressions and that the system's integrity was maintained.
The deployment process, often prone to human errors, was fully automated through GitHub Actions. After a pull request approval and merge into the master branch, a deployment pipeline was triggered. This pipeline packaged the application, transferred it to the production server via SFTP, and executed specific startup and update procedures.
A gradual deployment strategy was adopted to mitigate risks. Instead of an instant update, the deployment process involved controlled steps. The new code was validated for stability, and then progressively implemented in production environments. This allowed for quick rollback in case of issues and ensured a seamless experience for end-users.