Jenkins on CentOS 10 Reviews

My main use case for Jenkins on CentOS 10 is to automate the application deployment process, making heavy use of CI/CD pipelines. We used Jenkins on CentOS 10 to automate the deployment process. The person responsible for that part, the manager, would go to the dashboard and hit play once everyone had confirmed that the changes were properly tested. From there, Jenkins on CentOS 10 built the application, registered it in Docker, updated the Helm chart for our application, and deployed it to the Kubernetes environment.

A specific example of how I use Jenkins on CentOS 10 pipelines with Docker in my workflow is a pipeline that had a Jenkinsfile stored in the project repository. In it, there were configurations for the images needed for the deployment process. We used the pipeline to build the updated image of the project. This pipeline also had another stage that handled registering this image in GitLab, which we used. After that, it updated the Helm chart version that we used in the Kubernetes environment. Finally, this pipeline deployed, installed, and updated the new version in the Kubernetes environment. In addition, we used these pipelines to diagnose and analyze the flow of this operation.

Another great use case I had was improved visibility of changes by version. The record of builds let us see which commits were being sent in each version and which versions had already been deployed, helping us investigate more clearly and roll back more quickly to previously successful versions.

Jenkins on CentOS 10 has positively impacted my organization by speeding up the deployment process and reducing the time we spent executing repetitive tasks. Since the automated deployment process let us start it and then continue working on other tasks, it also reduced errors in writing or executing manual commands. In addition, it reduced the need to share permission files for using the Kubernetes production environment of the application, since all usage configuration was centralized in Jenkins on CentOS 10 with restricted access only for responsible people.

Regarding the specific outcomes, we have started delivering much faster. In situations requiring a critical or emergency deployment, using Jenkins on CentOS 10 made updates quick and efficient, so necessary changes reached users faster, reducing our time, our rework, and the occurrence of errors during the deployment process. It also helped with documenting the process. If the infra developers were likely to leave for other opportunities, the deployment process was not interrupted or harmed because it was already very well configured in Jenkins on CentOS 10.

The best features Jenkins on CentOS 10 offers are the deployment process through declarative files, which makes it more standardized and easier to reuse. Also, once the deployment process is configured well, it can be run even by someone without technical experience or knowledge, just by using the dashboard. The dashboard is simple and practical to use. It has many plugins, which makes integration with various other tools easy. Plugins such as Stage View make it easier to visualize and diagnose the deployment process. Besides centralizing this process, another interesting feature is using it for jobs and actions that are not necessarily about deployment, but routine processes such as tests or other functions.

The dashboard and centralized process really help my team day-to-day by making things both easier and faster. Since we didn’t need to run all the commands manually, any change pushed to the repository could quickly trigger the deployment process just by clicking the play button on the specific project. It really made usage faster and easier, helping updates go live more quickly and more efficiently, and avoiding mistakes such as forgetting a command that needed to be run in the middle of the process.

Another interesting feature I enjoy is Jenkins as code. Even though the documentation is not very clear, it still offers a practical and quick way to preconfigure or replicate Jenkins on CentOS 10 configurations.

To improve Jenkins on CentOS 10, there are some challenges we ran into, especially when we first started using it. We missed clearer documentation, both for Jenkins as code and for some environment configurations. As a result, a lot of configurations were learned manually through tests with the team. We also missed more stable plugin updates. We had many problems with incompatibility between plugin versions in Jenkins on CentOS 10.

What makes those situations challenging is that we had problems starting and restarting the Jenkins on CentOS 10 application when we needed to reuse plugins from the previous version. Once we updated some plugins to the required version, others became incompatible with the current version. It became a cycle where we had to update Jenkins on CentOS 10, the versions of the plugins we used, and the versions of the plugins they depended on, which made configuration and startup quite difficult in some cases.

I have been using Jenkins on CentOS 10 for practically most of this work for about four years.

In my experience, Jenkins on CentOS 10 has been very stable, really very stable. The difficulties we faced involved only poor resource sizing or outdated plugins. Jenkins on CentOS 10 itself was always very stable.

The scalability of Jenkins on CentOS 10 is quite good, and the ease of configuration for new projects makes the process very scalable. In our Kubernetes environment, the only limitation is monitoring resource levels so that the containers for new processes and new applications can start without choking the others. Jenkins on CentOS 10 does have the capacity for growth, but that growth needs to be planned carefully so it doesn’t strangle other parts of the cloud environment.

The community itself was more necessary and more useful than actually contacting support.

Since I didn’t use customer support, I’ll give it a seven.

In the company project, I didn't previously use a different solution before using Jenkins on CentOS 10. It was always Jenkins on CentOS 10. Before that, my personal experience was just manual deployment via terminal.

We use Jenkins on CentOS 10 in a Kubernetes environment.

We definitely had a return on investment because of the speed in the deployment process, the automation, and the improvement in documentation of these processes, plus the faster visibility of the deployment process. I think that already pays off because of the time saved in our daily work.

My experience with pricing, setup cost, and licensing for Jenkins on CentOS 10 was very simple. We didn’t have any issues with that. The biggest cost is infrastructure resources to allocate the machine.

When I used Jenkins on CentOS 10, I didn’t have the power to choose; it was already used in the company. Today, however, I wouldn’t choose another tool to handle this process. Jenkins on CentOS 10 would indeed be my first option.

Before choosing Jenkins on CentOS 10, it’s important to know what resources the company has for configuration, as well as the human resources and skills of employees needed to properly configure a pipeline environment. Besides that, I would look at and compare tools such as GitLab, GitLab CI, and others such as container-focused tools or Docker-based automation tools to automate image processes for simpler, smaller applications. Those can also be good options.

On a scale of 1 to 10, I would rate Jenkins on CentOS 10 a nine.

I chose nine out of ten for Jenkins on CentOS 10 because it’s really very useful. It really brought many benefits to our business, and I know there are still many features we could have used that would have made the company's day-to-day life even easier and better. However, it’s not a 10 yet for me because I find the system documentation hard to read and not very clear. I also think there’s a barrier for people who are not very into the DevOps side of things. In addition, plugin incompatibility can become a problem in some cases when restarting the project and handling versioning.

As with all AI usage now, I think the AI capabilities of Jenkins on CentOS 10 need to be used carefully. I find the Jenkins on CentOS 10 environment very suitable for AI use, but I think it should be very limited and have very clear rules. A bad configuration of a deployment process or tasks typically handled in Jenkins on CentOS 10 can cause problems for the entire operation. I don’t think governance and security themselves are a problem, but I think usage should be done carefully and with reduced permissions to avoid causing serious application errors.

I think the AI capabilities of Jenkins on CentOS 10 already have robust rules to avoid possible errors in the accuracy and reliability of output. I really like the configurations that are already available. I think its use could be very productive, since it could help diagnose errors and suggest improvements for the deployment flow and automated actions.

My recommendation to others reading reviews on PeerSpot who are looking into using Jenkins on CentOS 10 is to make good use of its capabilities. Automate processes in a clear, declarative, and organized way to make diagnosis easier. I would build an image or correctly save references of the plugins you use, because that can be very useful and necessary when you need to restart the application. I would also document what you have to do as part of the process.

Our main use case for Jenkins on CentOS 10 is to run our CI/CD pipelines, so whenever code gets checked in, Jenkins triggers the integration pipelines, the build pipelines, and PR reviews. Jenkins is also handling the deployment of those codes.

Whenever a new feature is being developed by the developers, they check in code, for example in a PR branch, and create a pull request with Jenkins for our CI pipelines or deployments. The moment a pull request is created, Jenkins webhooks are called and they trigger a check of the PR, especially checking for code smells, the mergeability of the PR, and security vulnerabilities in the code. Once that runs and there is an approval comment on the PR that somebody merges, it triggers another build pipeline which builds the package with a Docker image. Once the image is available, the deployment pipeline gets triggered and called, and finally the application or the changes that are part of the feature get deployed. Once it deploys, there are also some post-deployment sanity scans that run on the application from Jenkins.

Jenkins on CentOS 10 is deployed in our organization on the public cloud, specifically using Azure, where we deploy it on virtual machines.

Jenkins on CentOS 10 has positively impacted our organization because it is free and open-source, helping to save a lot of cost on our end. It is customizable since you can add different plugins or whatever you need through Jenkins, and it is very scalable due to the distributed architecture Jenkins has. We are able to efficiently run multiple projects and pipelines, and the large community support for Jenkins means that if there are any issues we run into, we can check out the community notes to fix things. Regular updates, especially security updates, are a major plus.

Regarding specific outcomes since adopting Jenkins on CentOS 10, time to market is what we call it, from the time a product feature is ideated to when the product is deployed. Previously, this process was manual, depending heavily on the developers and ops team to create and deploy packages. Now that we have Jenkins on CentOS 10, things are automated, and we are not dependent on the developers anymore; it is all system-driven with code getting checked in. All the issues coming out of the code are then fixed and deployed, so the time to market is very short now. We are able to deliver multiple features within a week, whereas it used to take three to four weeks to do the same work, translating to cost savings as we are doing more for less. These are positive metrics that show Jenkins helping us in our organization.

The best features that Jenkins on CentOS 10 offers are that it is easy to install and configure. Jenkins has always been a tool that is easy to install and configure. Out of the box, you are able to run a lot of different CI/CD pipelines because the configuration part is also quite simple. It does specific things, but it does it very well.

The difference for our team with Jenkins on CentOS 10 is that we do not really need to install it again and again. The fact that whenever we started doing this and started figuring things out, we can run Jenkins on Docker and test it out and do work on it helps our team a lot, especially since it comes with so many different plugins.

The accuracy and reliability of output for Jenkins on CentOS 10's AI capabilities is pretty good. The AI agents are already trained with good data, so they explain errors in the console output very well and analyze errors in the pipeline, log filtering, and basic functionality that is very useful. It is smart and quite accurate, and I am pretty satisfied with what it has on offer.

Regarding how Jenkins on CentOS 10 can be improved, it is not specific to CentOS 10, but Jenkins is a bit resource-intensive. It consumes significant system resources, especially if there are large codebases running or large projects running, and running it on a server does cost money. If Jenkins could help in that aspect, it would be beneficial, especially considering there are other alternatives in the market, such as GitHub Actions, which does more or less the same or even much more than Jenkins. However, the advantage is that Jenkins is an open-source tool, allowing unlimited usage. The downside is that it consumes a lot of compute power, which we need to provision. Additionally, Jenkins has complexity, particularly for beginners; I have substantial experience, but for newcomers looking to manage Jenkins, the setup can be complex. I think Jenkins needs to listen to common users and make things easier, especially now with the age of AI, and some integration to assist users would be beneficial.

Regarding Jenkins on CentOS 10's AI capabilities, I think it has some security risks since any kind of plugins can be added by people, which if misconfigured or containing malicious elements, can introduce vulnerabilities into Jenkins. That aspect needs to be governed.

We have been using Jenkins on CentOS 10 for two and a half years on this platform. Before this, Jenkins has been around for a long time, as we had been using it long ago for other use cases, but in this organization, we have been using it since probably early 2025.

Jenkins on CentOS 10 is quite stable.

Jenkins on CentOS 10's scalability is excellent because of its distributed architecture. It is extremely scalable.

We previously used GitHub Actions before switching to Jenkins on CentOS 10, and that solution was easier, but we switched because it became costly. Running a lot of different CI/CD pipelines and various test cases on GitHub Actions often exceeded the limited number of minutes per month, resulting in significant costs. Therefore, we found ourselves switching to Jenkins on CentOS 10.

I have seen a return on investment with Jenkins on CentOS 10, as it has saved us and reduced our time to market. Previously, a feature would take one month to reach from ideation to production deployment, but now we do that within a week. We employ a lot of AI as well, and Jenkins on CentOS 10 integration supports that achievement, making it clear that time saved translates to money saved. We are now three times more productive with Jenkins on CentOS 10.

My experience with pricing, setup cost, and licensing for Jenkins on CentOS 10 is that since Jenkins on CentOS 10 is an open-source tool, the only expense we have is the compute costs and server costs. Given its resource-intensive nature, we need to provision higher-end servers to run it effectively, so that is an area where Jenkins on CentOS 10 needs to improve to become less resource-hungry and more cost-efficient.

Before choosing Jenkins on CentOS 10, we evaluated other options, including Azure DevOps, but setting that up was not easy and posed challenges. Additionally, Azure DevOps incurs costs. Therefore, Jenkins on CentOS 10 was the only other viable option we considered due to its open-source nature.

I choose eight out of ten for Jenkins on CentOS 10 because it has significantly helped us reduce time to market, along with enhancing our CI/CD setup, addressing different requirements, and supporting continuous testing, along with continuous quality and code checks. However, there are still some limitations, particularly the resource-intensive nature of Jenkins on CentOS 10 and the complexity of the setup. If those two aspects improve, I think it could be a ten out of ten. I would advise others looking into using Jenkins on CentOS 10 that they should use it if they or their team have the capability or experience to use it. Jenkins on CentOS 10 natively is a bit complex to set up and maintain, but it provides a lot of useful returns on investment and is very cost-effective, so those skill sets are essential to make it work effectively.

My main use case for Jenkins on CentOS 10 is automating CI/CD pipelines for Java applications. I use Jenkins to build, test, and deploy Spring Boot microservices with integration to tools such as Maven, Docker, SonarQube, and Kubernetes.

Jenkins on CentOS 10 fits into the handoff from our Spring Boot builds and tests through Docker and Kubernetes deployment by acting as the main CI/CD automation tool in my development process. When developers push code to Git, Jenkins automatically triggers the pipeline. First, it builds the Spring Boot application using Maven and runs unit and integration tests using JUnit and Mockito. Next, Jenkins performs code quality checks using SonarQube. If all checks pass, Jenkins builds a Docker image and pushes it to a container registry. Finally, Jenkins deploys the new version to Kubernetes using rolling updates with minimum downtime. This process ensures consistent, reliable, and automated deployments.

Jenkins on CentOS 10 is deployed in our organization in a hybrid cloud environment, combining on-premises infrastructure with cloud services. Jenkins manages our CI/CD pipeline, automating build, test, and deployment for Java and Spring Boot applications. This approach provides flexibility, security, and scalability.

Jenkins on CentOS 10 has had a very positive impact on our development process. Using Jenkins on CentOS 10, I can automate CI/CD pipelines, integrating with Docker and Kubernetes to improve the quality of our Java and Spring Boot applications.

One of the biggest improvements we have seen since adopting Jenkins on CentOS 10 is the reduction in deployment time and manual effort. By automating our CI/CD pipeline in Jenkins, we significantly reduced repetitive tasks and improved deployment consistency. We also experienced fewer deployment issues because automated tests and code quality checks help in identifying problems before production. This allows our team to release new features faster and with greater confidence.

The best features of Jenkins on CentOS 10 are its flexible automation capabilities and integration with DevOps tools. In my experience, the most important features are CI/CD pipeline automation for building, testing, and deployment; pipeline as code using Jenkinsfiles to manage pipelines directly as code in Git; Docker integration for building and publishing container images; Kubernetes integration for automating microservice deployments; a plugin ecosystem for integrating with Maven, SonarQube, Git, and other tools; distributed builds using Jenkins agents to execute jobs in parallel; and security for managing credentials and controlling access to pipelines.

The feature that has made the biggest practical difference for my team is CI/CD pipeline automation in Jenkins on CentOS 10. Before automation, building, testing, and deployment required manual work, which increased the risk of error. Now Jenkins on CentOS 10 automates the entire process.

I believe that Jenkins on CentOS 10 could be improved in the main areas of performance, security, and ease of maintenance. First, Jenkins on CentOS 10 could provide better capabilities in these areas.

Specifically, for my team, the following improvements to Jenkins on CentOS 10 would be impactful. For performance, using dedicated Jenkins agents and parallel pipeline execution reduces build times. I would also implement Maven dependency caching to avoid unnecessary downloads. For security, I would improve credential management with secure plugins, implement role-based access control, and regularly update Jenkins and its plugins. For maintenance, I would standardize Jenkinsfiles using shared libraries, avoid duplicating code, and implement better monitoring with Prometheus and Grafana. These improvements would help the team reduce pipeline execution time, strengthen security, and make CI/CD maintenance easier.

I would also suggest additional improvements to Jenkins on CentOS 10, including a better user interface, simpler plugin management, and stronger integration with cloud-native technologies. Another important improvement would be better error reporting and troubleshooting tools to make it easier to identify and resolve problems. These improvements would help our team save time, reduce maintenance costs, and increase productivity. Overall, Jenkins is a powerful CI/CD tool, but making it simpler, faster, and more secure would provide even greater value.

I have been using Java for over 20 years.

Jenkins on CentOS 10 is generally stable and reliable, especially when properly configured and maintained. In my experience, Jenkins provides consistent CI/CD automation for Java and Spring Boot applications. Regular updates, proper resource management, and monitoring help prevent performance issues and downtime.

Jenkins on CentOS 10 scales very well.

I would rate the customer support for Jenkins on CentOS 10 a 10 on a scale of one to 10.

Before adopting Jenkins on CentOS 10, I had experience with other CI/CD solutions, including GitLab CI/CD and Azure DevOps. We chose Jenkins because of its flexibility, open-source license, extensive plugin ecosystem, and strong integration with Java, Maven, Docker, and Kubernetes. It also allows us to customize pipelines according to the team's requirements. Overall, Jenkins provides greater flexibility and control over the CI/CD process.

I believe Jenkins on CentOS 10 delivers a positive return on investment for the team. The biggest benefits have been time savings, reduced manual effort, and more reliable deployments. By automating building, testing, and deployment, we spend less time on repetitive tasks and more time developing new features. We have also improved deployment consistency and reduced the risk of manual error. Although I don't have strict financial metrics, the improvements in productivity and efficiency have been significant.

Regarding pricing, setup costs, and licensing, Jenkins on CentOS 10 is a cost-effective solution because it is open-source and doesn't require license fees. The main costs are related to infrastructure, initial setup, maintenance, and technical support. Running Jenkins on CentOS 10 can help reduce operating system licensing costs as well. However, there are additional expenses related to cloud resources, storage, security tools, plugins, maintenance, and dedicated build agents. Overall, I believe the cost is reasonable, especially considering the benefits of CI/CD automation, improved productivity, and reduced manual effort.

Before choosing Jenkins on CentOS 10, we considered other CI/CD solutions, including GitLab CI/CD, Azure DevOps, and GitHub Actions. We compared factors such as cost, flexibility, integration capabilities, security, and maintenance. Jenkins stood out because of its open-source model, extensive plugin ecosystem, and strong integration with Java, Spring Boot, Docker, and Kubernetes. Overall, Jenkins was a good fit for our technical requirements.

I have over 20 years of experience in software development, specializing in Java, Spring Boot, microservices, and cloud technology.

I would rate Jenkins on CentOS 10 an eight out of 10 overall.

I think Jenkins on CentOS 10 provides a solid foundation for security and governance, but its use of AI capabilities needs improvement. Jenkins offers successful security features such as role-based access control, credential management, and audit logging through plugins. When integrating AI tools, I believe strong governance is necessary, especially for data privacy, access control, and monitoring AI-generated code. I would recommend implementing automated security checks, approval workflows, and human validation before deploying AI-generated changes to production. Overall, I believe AI should improve automation without compromising security through human control.

I think Jenkins on CentOS 10 is reliable for CI/CD automation, and the accuracy of AI-generated output depends on the AI tool integrated with Jenkins. AI can help identify errors, analyze logs, and suggest improvements. However, AI-generated results are not always accurate and should be validated.

For teams considering Jenkins on CentOS 10 as a flexible, cost-effective CI/CD solution, my advice is to start with a well-planned setup, focus on security, and automate building, testing, and deployment from the beginning. I also recommend using Jenkinsfile, Docker, and Kubernetes to standardize the deployment process. Regular updates, monitoring, and proper plugin management are essential for long-term stability. Overall, Jenkins is a powerful tool that can significantly improve deployment, productivity, and software delivery.

We use Jenkins on CentOS 10 to automate pipelines for deployment, build, continuous delivery, integration, and automated tests. We have also been using Jenkins on CentOS 10 extensively to automate the resolution of tickets and cards that are opened for us.

We have a pipeline that uses Jenkins on CentOS 10 to import dashboards from another team, the SRE team. The dashboard is a Grafana dashboard that is converted from the model we use in the cloud to the model we use on-premises in Kubernetes. The pipeline fetches the dashboard, performs the conversion by removing parameters and converting the data sources, makes some modifications inside the dashboard JSON, and then deploys the dashboard to Grafana for on-premises use. We also use Jenkins on CentOS 10 as a build tool for new APIs within projects or teams.

We also use Jenkins on CentOS 10 for infrastructure provisioning. We use a card or ticket where everything we need in the environment is described. Jenkins on CentOS 10 reads this card and provisions the environment. It provisions RDS, EC2, APIs, code, and everything else that is needed. If the card is moved to another type or status, Jenkins on CentOS 10 receives a webhook, and the environment is modified according to the changes in the card.

Jenkins on CentOS 10 has had a positive impact on our organization because it has significantly reduced the time we spend on deploys. It has greatly improved the testing aspect, so we can integrate various tests within a single pipeline without causing delays in application delivery. We have also managed to give teams more control so they can access the pipelines, understand what is going on, and even fix code errors during the build stage before anything goes to the environments. We have also gained very broad visibility into all the metrics by using the DORA Metrics standard, which shows us what we can improve within the pipeline, in code quality, delivery, errors, and more.

We measure the reduction in deployment time with Jenkins on CentOS 10 by using an integration within Grafana itself, which gets data from the Jenkins API. We also use an exporter, which is a plugin that sends logs to Loki, and from Loki we can obtain the pipeline error logs in a more comprehensive way. We can also gather this information from developer feedback.

The best features that Jenkins on CentOS 10 offers include plugin integration. It integrates easily with several tools on the market, at least the main ones.

The programming language gives it a lot of versatility. We are able to do things that we normally cannot do in other pipelines, such as GitHub Actions, Azure DevOps, or GitLab CI itself. We can integrate other programming languages with it.

We can also make heavy use of the concept of templates. We declare and create pipelines that create pipelines for the teams, using the seed job model that Jenkins on CentOS 10 itself provides.

I think the overall performance of Jenkins on CentOS 10 could be improved because it ends up consuming a bit more memory.

I give it that number because I feel it could still have a pipeline defined in YAML, using both Groovy and YAML to define a pipeline.

Regarding the AI features of Jenkins on CentOS 10, at first glance they are very good, but they still need a bit more refinement.

I have been using Jenkins on CentOS 10 for six years, since I started working as a DevOps engineer.

On a scale of 1 to 10, I would rate Jenkins on CentOS 10 a nine overall.

Jenkins on CentOS 10 is deployed in our organization in a hybrid cloud, where we have one Jenkins instance that coordinates several Jenkins instances spread around the world. Each region has its own master and its slaves.

We use AWS as our cloud provider.

My advice to others who are thinking about using Jenkins on CentOS 10 is to carefully evaluate your needs. Properly structure the beginning of the pipelines, including how governance and management of the pipelines within the repositories will work. Also, carefully structure the Shared Libraries.

My main use case for Jenkins on CentOS 10 is to integrate automated tests into CI/CD pipelines, allowing the checks to run automatically. I used Jenkins on CentOS 10 for several years in test automation projects and continuous integration. I worked with different test frameworks, including Selenium and, later on, more modern tools. Jenkins on CentOS 10 helped organize executions, track results, and identify failures before releases.

As a specific example of how I used Jenkins on CentOS 10 to organize executions and handle failures before releases, I set things up so that my automated tests would run, and I configured flags in the code. Every time there was a PR from the development team, it would identify which code section was related to that change and which tests were relevant, run those tests automatically, and notify us whether there was a failure. If the tests passed, it would automatically approve the PR. If they failed, it notified the team, and we discussed the failure and worked on the fix.

Jenkins on CentOS 10 made this journey much faster. We were able to have error predictability, anticipate failures, and prevent defective code from being introduced into production. It helped make the team’s productivity more assertive and more quality-oriented.

Jenkins on CentOS 10 has had a very positive impact on my organization. It gave us predictability and automation. Things that used to take us a long time to do, we managed to automate, so we are able to meet time windows and our targets with the client. It gave us more time and free hands to work on other project demands by automating everything and keeping everything very well tied together.

As a concrete example of improvement, we reduced escaped bugs by 60% after adopting the automated CI/CD process. Regarding time, we used to spend around eight hours on the entire process of deployment, manual post-validation, and other tasks, and we managed to reduce that to forty minutes.

In my opinion, the best feature that Jenkins on CentOS 10 offers is its flexibility. It allows you to integrate different tools, languages, and frameworks into the same CI/CD process. Another positive point is the number of plugins available, which greatly facilitates integration with Git repositories, testing tools, and notification systems, for example. I also consider it important that you can configure customized pipelines according to each project’s needs.

Regarding flexibility and plugins, the ones I consider indispensable for my day-to-day work are the Git plugin, for sure, and the Playwright plugin, to build my automation projects and run them. I think those two are really fundamental in my daily work.

Regarding the AI features of Jenkins on CentOS 10, I think its governance and security are very robust, and it makes us feel confident. There were no restrictions on using it with clients. Clients who are familiar with this topic also did not avoid it; they did not tell us not to use it. So I think it is very robust and very secure.

So far, based on what we have used of the AI features of Jenkins on CentOS 10, I see very good results.

I believe the main challenges with Jenkins on CentOS 10 are in maintenance. Precisely because it is very flexible, we need to spend considerable effort on configuration and monitoring. Depending on how many plugins we use, compatibility issues may arise during updates. I also consider the interface a bit unintuitive compared to more modern solutions. I think the developers could invest more time in addressing these two points, maintenance and usability, by making Jenkins on CentOS 10 more user-friendly and more usable, with an easier and more intuitive interface.

I have been using Jenkins on CentOS 10 for about six years.

Jenkins on CentOS 10 is stable in my experience.

Regarding Jenkins on CentOS 10’s ability to handle increased demand, whether in the number of pipelines, users, or simultaneous projects, I do not notice any limitation. It has performed well as we have grown.

For support with Jenkins on CentOS 10, I turn to the community and, recently, to AI whenever I need help. I never contacted or needed to contact the Jenkins developers or team.

I have used other solutions before, but always due to the client’s needs. Whenever I have the freedom and flexibility to choose, I go with Jenkins on CentOS 10.

Before choosing Jenkins on CentOS 10, I did not evaluate other options. I chose Jenkins on CentOS 10 based on the experience of colleagues, communities, and other companies. It is a tool with a really active community, and it is very widely recommended and well-reviewed.

On a scale from 1 to 10, I would rate Jenkins on CentOS 10 a seven.

I rate it a seven exactly because of what I mentioned: it fulfills the functions, it meets everything we need, and it helps a lot, but the three points needed to reach a ten are the improvements I mentioned in the previous question.

Jenkins on CentOS 10 is deployed in my organization on-premises. Actually, it is not even on-premises in the usual sense; it is on our company’s internal server.

My advice to others who are considering using Jenkins on CentOS 10 is to go ahead and use it. It has a very active community. There is a lot of material on the internet that enables you to quickly configure it and make it work and run perfectly in your daily routine. There are many plugins, and it basically connects with everything you use in your daily work, any technology. You will save a lot of manual effort with the deployment process and with manual test execution. It will bring predictability, effort reduction, and financial gain in the end for your team.

My main use case for Jenkins on CentOS 10 is a big project in which I create a great pipeline for a company where I work as a head engineer. I create a big pipeline with many integrations in Jenkins on CentOS 10 to deploy, build, and start many microservices.

In this project, I connect a Bitbucket integration with JFrog into the Jenkins on CentOS 10 pipeline. I use AWS to deploy this in EKS and other AWS services, such as EC2, S3, and load balancer, to help run those microservices.

In this project, I work extensively with Kubernetes, so I use Helm and other Kubernetes services for great performance and good design patterns.

Jenkins on CentOS 10 has impacted my organization positively by accelerating our CI/CD deployment process.

The deployment frequency in my company is daily. Every day, we deploy eight microservices, and I think each deployment takes ten minutes at most. The manual effort is small, and the process is easy and fast.

I think the best feature Jenkins on CentOS 10 offers is the ease of integration. I cannot name a single best feature, but I think Jenkins on CentOS 10 is very powerful and easy to understand and use, and I think this is its greatest strength.

Jenkins on CentOS 10 is a main service in my company and is very important in our architecture. All of our services, microservices, sites, websites, and systems depend on it.

I have nothing further to add on this point.

I think the process of installing Jenkins on CentOS 10 in an environment could be improved in many cases.

I think simpler packaging and faster provisioning would make that setup process better for my team.

I have been using Jenkins on CentOS 10 since 2017.

Jenkins on CentOS 10 is stable.

The scalability of Jenkins on CentOS 10 is easy, very easy, and great.

We used a customized home solution before, which was bad. It was complicated and broke often, every week. We switched because it was impossible to maintain our solution, which was a legacy solution from 20 years ago.

I think the relevant metric for return on investment is time saved. Jenkins on CentOS 10 gives back a lot of time, allowing me to work with my colleagues on other tasks and make better use of their abilities. It also helps save money because it is easy to maintain and to share services with other services. This matters a great deal to my team.

I estimate that we save about eight hours per week.

I think the pricing is good, and the licensing is okay. All services in AWS and private cloud are usually very expensive, but Jenkins on CentOS 10 is not one of them.

We evaluated other options, such as CloudFormation in AWS and Bamboo in Azure, but they do not offer the same delivery, and I think Jenkins on CentOS 10 is better for all services.

I would tell anyone researching Jenkins on CentOS 10 on PeerSpot that I rate it a nine because it is a great project and very important in the IT world. I give it a nine because we can always improve the services, and I do not like to give a ten.

I think Jenkins on CentOS 10 is good for governance and security.

For accuracy and reliability, I think Jenkins on CentOS 10 is great, and I rate it a ten on this point because of its great impact on my company and all of our other work.

We use Jenkins on CentOS 10 in a private cloud, but in some projects, we use it on-premises.

We use AWS.

We only look at other solutions to understand the market.

The main use case for Jenkins on CentOS 10 is to monitor the pipeline when I deploy software to environments, staging or production.

For example, I deploy the branch I have to CloudFront. I trigger the process to start and follow in Jenkins which stage it is running in. If there is any problem, I can analyze the logs from that point to see what happened and what the actual problem was. Jenkins also gives me a more general view of how long each branch normally takes and what other projects are being deployed and running a pipeline. I have that visualization.

Jenkins on CentOS 10 helps me understand each new portion of software during CI/CD. It helps me understand at which stage something is happening and what the status is. One situation that I find very interesting is the time each step of the pipeline takes. I have a sense, for example, of whether the pipeline that is currently running is within a standard time, or whether it is taking longer, is slower, or has changed in some way. I really appreciate seeing what happens in each stage, because sometimes a pipeline is at a certain stage and I want to see details. I can see if from there it is calling some other tool; for example, Checkmarx is a tool I see a lot in vulnerability analysis. That is where Jenkins on CentOS 10 really helps me understand what is happening. It gives me a deep view of what is going on and what the current situation is.

Jenkins on CentOS 10 has a very positive impact when I understand what is happening at the moment I am deploying software to some environment, staging or production. This helps me a lot to understand at what point the software is.

I measure this impact by noting that there was a decrease in errors because we understand what is happening.

The best features that Jenkins on CentOS 10 offers, in my opinion, are the detailed breakdown of the stages. That is what is most important for me. I can understand the stage that is running and what is actually happening, literally, in that stage. That level of detail helps me a lot. I can also see whether that is within the normal range, or, even if there is no problem, I can analyze a deeper status. That is very interesting.

Regarding this detailed breakdown of the stages, all three functionalities are specific platform functionalities that I frequently use to deepen this analysis. Log visualization is very important because when a problem occurs, I want to understand what happened. Even if there was no problem, I can understand what is really happening in that stage. That is very important. The dashboard helps me a lot to understand how the company is using Jenkins on CentOS 10 at the same time I am using it. For example, if I am running a pipeline now, I can see which other pipelines are running, whether they are all taking a long time, and whether mine has priority over the others. Regarding alerts, when something fails, Jenkins on CentOS 10 sends messages in the company's Google Chat to other responsible people. That helps a lot. It also helps if, for example, it is going to contact some other software that runs alongside it, such as Checkmarx for vulnerability analysis. That helps a lot to understand the whole picture.

In this case, I use Jenkins on CentOS 10 integrated with AWS. It helps me a lot.

Regarding the AI features of Jenkins on CentOS 10, they help me a lot because, through the analysis of my situation and my use of Jenkins, the suggestions become more effective and better.

Regarding the AI features of Jenkins on CentOS 10, I find them to be highly accurate because they really seem to know how to use the collected data to bring me good suggestions.

I believe Jenkins on CentOS 10 can be improved by allowing some customizations in the dashboard in a more immediate way. It would also be interesting to allow this customization for each user. For example, I use another tool in which I can already leave some fields fixed, and I can pin some fields. That helps me a lot in that other tool. It would be interesting to have this in Jenkins on CentOS 10 since it is a tool I use constantly.

My rating of nine is due to the customization I mentioned, which would make me give it a 10.

I have been using Jenkins on CentOS 10 for about two and a half years.

Jenkins on CentOS 10 is stable. When a problem occurs, they manage to resolve it quickly.

I imagine Jenkins on CentOS 10 works well regarding scalability. I do not see any problems related to that.

I do not have access to customer support details, but I believe it works well since the company continues to use it and it is a large company.

I did not previously use a different solution; since I joined the company, we have used Jenkins on CentOS 10.

I can already see time saved as a return on investment.

I do not have access to pricing, setup costs, and licensing information, but I understand that the company uses it and keeps using it.

Before choosing Jenkins on CentOS 10, I did not have access to that part, but I believe they did evaluate others.

On a scale from 1 to 10, I would rate Jenkins on CentOS 10 a nine.

I would say that Jenkins on CentOS 10 will contribute to better visibility of how systems are working and going to the environments.

My main use case for Jenkins on CentOS 10 is setting up a pipeline with the repository so that we can create the queue between Sonar and SAST. Within this pipeline, it determines whether the process can continue or not. I also linked the pipeline to the environments that are needed for testing.

In practice, the pipeline in Jenkins on CentOS 10 works in the following way. When we generate the build, we specify the version and the branch that we will be working on. As soon as the pipeline is set up, I run flows of unit tests and Sonar, which is important to see if there is any kind of break, bug, or major issue. After the unit tests pass with no build break, the pipeline goes through Sonar. After Sonar, I run SAST checks, which are precisely to identify security-related issues and to see if the code is ready for production. Once it has passed these four scenarios, I deploy to the environments that are needed and that the team is working with. You can configure that in the pipeline as well.

At the moment, I don't have anything else to add about this flow on Jenkins on CentOS 10. I gave a basic flow. If there is a basic requirement that is important for PeerSpot, I can explain it. Otherwise, this is ideal, because I would otherwise be getting into details that are confidential to my company.

In my experience, Jenkins on CentOS 10 has had a positive impact on my organization, mainly through automation. It helped me a lot, including with OpenShift issues for traceability. Everything in that tool, currently and in the past, meets my needs. I also work in other places, doing my own gigs, and when I use Jenkins on CentOS 10, it is very easy for me to point out what I am going to do, how I am going to create the automation, where I am going to apply the project, and what I am going to put in the pipeline to follow the flow. That depends on the client I am working with, so I always align to the need. Today I work with several banking models and with OWASP, so I apply everything involving security in the pipeline.

Regarding the impact of automation with Jenkins on CentOS 10 on time saved, error reduction, or productivity, however, I see an impact in the teams I work with when we implement Sonar or automated tests, or actually the unit tests. Later, I am even adding automated tests for future projects as well, to run with Cypress and Playwright. This is precisely about running an end-to-end test in an environment and avoiding impacts. Having these scenarios, just the unit tests or Sonar and integrated tests, already avoids rework. When you have a perfect flow following this and you have that scenario, it reduces rework by about 60%.

The best features Jenkins on CentOS 10 offers in my experience are the automation aspect and CI/CD, which I use a lot. The Jenkinsfile is also valuable for versioning and doing automations. Other valuable features include automated tests, Sonar, Jacoco, and the automated deployment that I mentioned for publishing to the environment. There is also rollback if something different shows up in production, so you can roll back. In addition, there are pipelines per branch, security credentials, and logging and monitoring through OpenShift.

Monitoring through OpenShift contributes a lot to my workflow, to check for bugs, issues, and even requests that were made differently. The integration between infrastructure and the end user is very important, because there I create traceability.

I don't want to add anything else about the features of Jenkins on CentOS 10. I work with some confidential things, so I am reluctant to talk about the technology I am working with at the moment. I am talking about things from companies I have worked for in the past, so as not to create any hint of an information leak.

Regarding the AI features of Jenkins on CentOS 10 for governance and security, it depends on what is in the pipeline. If you implement everything properly there, including things related to SAST, then it will work. It all depends on the client you are working with. If you put the right configurations in the pipeline, in the pipeline queue of what must pass, then it creates adequate security. If you leave it empty, there will be nothing.

Regarding the accuracy and reliability of the AI results from Jenkins on CentOS 10, they are good. I think from now on, the questions need to be more objective.

To answer how Jenkins on CentOS 10 can be improved, I would have to compare it with other tools, for example Azure, because Azure is already integrated with AI. GitHub Actions is also already integrated with AI. This is a bit out of scope, but even for PRs, they evaluate the code itself, what is there, and what can be improved. In addition to Sonar, it basically tells you what really needs to be improved and gives very practical suggestions.

For now, I have no additional improvements to suggest for Jenkins on CentOS 10.

I have been using Jenkins on CentOS 10 for about eight years.

In my experience, the stability of Jenkins on CentOS 10 depends on what I have already mentioned. It depends on the way you build the pipeline and the way you build security, as well as on stability and maintenance. It is a server that gets continuous updates, and it is stable.

Regarding the scalability of Jenkins on CentOS 10, it depends on whether you are talking about vertical or horizontal scalability.

Regarding customer support for Jenkins on CentOS 10, it says that official enterprise support with SLA is not included. I think that is the only thing.

I would rate customer support for Jenkins on CentOS 10 an eight.

I used Jenkins on CentOS 10 itself, but it was integrated with AWS, and there the services were mixed with infrastructure, so it was a big expense bundle.

Regarding return on investment with Jenkins on CentOS 10, it depends, because I have worked at large scale. It depends a lot on the client and the signed contract. When you work with a cloud server, there are infrastructure things built in, so it ends up creating a mix, and I can't estimate a value in that case.

However, I know that there were places that closed contracts of almost 100,000, but there were also contracts of 10 and contracts of 50. The client I worked with in the past was city-focused, so appropriate billing depended on the size of the city, because it depended on data traffic.

In terms of pricing, setup costs, and licensing for Jenkins on CentOS 10, the prices are really just for companies. I don't feel that, for example, I as an individual customer would have that.

You just have basic plans that are free to do one test or another, not something heavy, because I feel that the prices are really targeted at companies.

Before choosing Jenkins on CentOS 10, I evaluated other options, and I had already mentioned GitHub Actions and Azure Pipelines. The difference from what I have presented is that they are easier to deal with regarding AI.

GitHub Actions is already integrated with Copilot itself. If there is a build error, it explains in detail where it was and why it happened, and it asks if you want it to make the change. Azure is the same thing. I don't feel that in Jenkins on CentOS 10.

I would rate Jenkins on CentOS 10 an eight out of 10 overall.

The reason I gave Jenkins on CentOS 10 an eight is that with the other tools, I am already feeling familiarity with AI, and I am not feeling much of that in Jenkins on CentOS 10.

How Jenkins on CentOS 10 is implemented in my organization depends on the situation. Today I can't talk about that, but I have worked with all three.

Regarding the cloud providers I have used with Jenkins on CentOS 10, I used many. I used AWS, and I used others, but I will only mention AWS.

My advice for others considering Jenkins on CentOS 10 is that it is a mature, free tool that supports projects of different sizes. However, I think configuration could be easier, as already happens with AI in GitHub Actions and Azure. If that improves, I think it will be at an excellent market standard. Overall, I consider it a good tool.

My main use case for Jenkins on CentOS 10 is CI/CD, providing an integration of various processes.

A specific example of how I use Jenkins on CentOS 10 for integration is the integration with Kubernetes, Docker, and Git.

Jenkins on CentOS 10 significantly helps my team.

The best features Jenkins on CentOS 10 offers include the feature of Jenkins, which I find essential.

I appreciate the automation using plugins with Jenkins on CentOS 10.

I find that using Jenkins on CentOS 10 has a positive impact on my organization.

Collaboration in my organization is enhanced using plugins and Git while working with Jenkins on CentOS 10.

I believe Jenkins on CentOS 10 can be improved with enhancements such as the Docker image in the Docker container.

The integration with Git is an aspect that could see needed improvements.

I think there could be improvements made with Jenkins on CentOS 10.

As a developer, I am using Jenkins on CentOS 10.

I have been using Jenkins on CentOS 10 for 22 years.

Jenkins on CentOS 10 is stable and reliable for my use.

I find the scalability of Jenkins on CentOS 10 to be effective, allowing me to manage growth.

I previously switched from using Ubuntu Linux before adopting Jenkins on CentOS 10.

The return on investment is favorable, reflecting in money saved and shared short.

My experience with pricing, setup cost, and licensing for Jenkins on CentOS 10 was very quick.

The distribution Linux was among the options I evaluated before choosing Jenkins on CentOS 10.

On a scale of 1 to 10, I would rate Jenkins on CentOS 10 a nine.

My overall rating for Jenkins on CentOS 10 is seven.

The reasons leading me to choose the number seven for Jenkins on CentOS 10 are multifaceted.

Regarding Jenkins on CentOS 10's AI capabilities, I think the security in the application is adequate.

In relation to Jenkins on CentOS 10's AI capabilities, I consider the duration to be acceptable for accuracy and reliability.

I would advise others looking into using Jenkins on CentOS 10 to consider the product carefully.

My main use case for Jenkins on CentOS 10 is CI/CD, development pipelines, and deploying to servers, taking code from a repository to the AWS machine.

A specific example of how this CI/CD process with Jenkins on CentOS 10 helped me in my day-to-day work is that it made the pipeline more automated. For example, we were able to make deployments in the CI/CD pipeline automatically through the trigger of a new merged PR in the repository.

Jenkins on CentOS 10 has had a positive impact on my organization in terms of time. The SLA was reduced significantly because we needed to be less manual and more automated.

I can quantify this SLA time reduction as 60% savings.

The best features that Jenkins on CentOS 10 offers include the ability to use various plugins together with Jenkins and to make connections and integrations with other systems.

The plugin I consider indispensable, which has greatly facilitated integration with other systems, is the Atlassian plugin, which is exactly the plugin for where we have our source code repository.

I think Jenkins on CentOS 10 could improve its integrations and its native repository, for example, for source code. One area where it loses out to its competitors is that it does not have the functionality to store your source code there and, from that, perform external automations and internal automations of your own source code. It also lacks the flexibility in automations that GitHub Actions has.

Jenkins on CentOS 10 could have more integration features, specifically features that change the market a bit and provide repositories, so it could be used as a source code repository and we could carry out automations and integrations more easily with our own code. I also think the UX/UI could be improved a lot. The Jenkins interface could be made simpler yet robust, so that we can work more easily and have more infrastructure and pipeline management controls.

I do not believe any other improvement is important for Jenkins on CentOS 10.

I used Jenkins on CentOS 10 for two years.

Jenkins on CentOS 10 is stable.

The scalability of Jenkins on CentOS 10 is good.

I previously used a different solution, Bitbucket Pipelines. We switched because it was a bit limited, very simple, and without much governance, and Jenkins offered us more.

I have obtained a return on investment. Time was saved, and with approximately 60% time savings, we can also reduce staff, which improves our payroll and increases our EBITDA.

We can have a positive ROI on the investment we made and on the internal cost we need to spend in order to use it.

In my experience with pricing, setup costs, and licensing, I found Jenkins on CentOS 10 expensive. This was one of the reasons it took us a while to actually start using it. The configuration is very burdensome, and that requirement is bad.

I think it should use AI more to make configurations faster, reduce the cost, and reduce the price for the end user. In this way, we would be able to use Jenkins on CentOS 10 more.

Before choosing Jenkins on CentOS 10, I evaluated other options such as GitLab and GitHub Actions.

On a scale from one to ten, I rate Jenkins on CentOS 10 a seven.

I chose a seven because it is a middle ground in my mind, between good and great. I do not think it is bad, but it is not great yet either.

Regarding the AI features of Jenkins on CentOS 10, I do not have much information about the use of AI with Jenkins, but I think the results are accurate and very reliable.

I acquired Jenkins on CentOS 10 through Jenkins itself or by recommendation.

The advice I would give to other people who are thinking about using Jenkins on CentOS 10 is that the learning curve needs to be a bit longer, so study and understand it well, and see whether this learning curve is really worth it for your process and your company in order to use Jenkins.