Jenkins on CentOS 10 Reviews

There are many main use cases for Jenkins on CentOS 10.

Jenkins is a tool that we can use for Continuous Integration, Continuous Delivery, or both. In my case, it solves the deployments that we need to make in several environments and several projects, with many specificities, and it allows us to automate this entire process.

Imagine that I had to do all of this work manually. I have an application, for example in Java, with quality gates that I need to run. Besides building the project in a certain environment, I need to build Java project A in a client's homologation environment A. If I did this manually, I would have to take the project over the network or via pen drive and upload it. Then I would need to correctly install the right versions of Java on that machine and compile the project manually. After compiling, I would have to take the project from the source and move it to a destination within the client's project where it needs to run. Before that, I would have to run the quality gates, which are the checks. If any check fails, I need to contact the Dev team or the support team first to fix what is needed.

The main use case is that I can automate this entire process for all of the projects that I run in Jenkins today. I gain speed, scalability, and above all control, because I can version everything I do. Every build pipeline I need for a given project is coded, versioned, and implemented in a controlled repository, so when I run it, I can be deterministic. I can run the same processes over and over, as many times as necessary, and I only change the variables that are mutable according to the environments I need to run in. That already saves me a lot of time in my process. In short, it greatly speeds up our day-to-day development flow.

There is a lot more I can add about our main use case for Jenkins on CentOS 10. For example, I can version Jenkins's own structure with JCasC, Jenkins Configuration as Code. Suppose a CentOS 11 distro is released and infra wants to migrate the server and the server service. I would have to implement and install everything, but with this configuration as code, I just migrate the configuration and bring Jenkins up. Jenkins then automatically loads my entire configuration scope, including users, the lists of libraries I need, and the security system.

Jenkins also has a simple scheme that is good but risky: you can copy the /var/lib/jenkins folder, which stores all the service data, and move it to a new server. You will be able to migrate a lot that way, although there will be some glitches. It is risky because if you suffer a security attack and your Jenkins is compromised, the risk of carrying malicious scripts to the new server is extremely high. That is why JCasC speeds things up.

Besides that, you can have Shared Libraries, pipelines, Jenkins Master, and Jenkins Slaves. You can have a pool of Jenkins instances, where a master controls everything and can be on Linux. If you have a project that only runs on a Windows server, you can spin up a Windows Server with a secondary Jenkins and orchestrate your pipeline within that Windows environment from your CentOS 10. Jenkins seems like a simple tool, but its potential is unlimited.

Regarding the positive impact Jenkins on CentOS 10 has had on our organization, one of the questions at the beginning of our conversation was how long I have been using Jenkins. I mentioned almost 12 or 13 years, but I do not know the exact date. We started using Jenkins around 2013 or 2014 because one of our main applications had a deployment problem. Deployment was slow, insecure, and carried many risks.

Before Jenkins, we had an FTP server connected to the production environment where our users were using the application. Over FTP, I would select a folder and place the source in it, meaning the code that was already correct, with the separated and adjusted folders for what I needed. Then I would simply use Ctrl+C and Ctrl+V to copy it to the destination folder. In this other folder, I saved the changes that I had implemented for the application.

This process had many problems, not even counting security. Besides security, we had slowness, network traffic, disk I/O, and network I/O. The deployment would have been much better if it had been properly implemented with a CI/CD process. Jenkins is just one CI/CD tool, and there are several on the market. I really like Jenkins because of everything I have mentioned. I could have done this with any other tool, and I believe there are tools on the market just as good as Jenkins, but in this case Jenkins offers this as well.

With that old process, we had slowness and risk. Sometimes the internet went down and I stopped the build halfway. Because of the I/O and slowness, the user on the other end ended up seeing a partial version of the feature that was being deployed. We had a lot of production errors. Sometimes the site or application would go offline during this process, sometimes for a minute or two. If you have a high number of clients and a high network throughput, you end up having a negative financial impact, which is complicated.

Jenkins solved this for us. First, we implemented it with a code versioning system, and we were already using Git. With Git, we managed to compile directly on a specific server that was on the same network as Jenkins. Before putting the code on, I can compile it in a separate, isolated environment without having to do it in the production environment. I also sync only what has changed and always keep the client's and the user's environment working properly with less downtime.

It was also possible to implement a blue-green deployment system. The application running in production points to the green environment. The build never goes to the environment where the user is currently viewing; it always goes to the opposite environment. If the user is seeing green, the build is entirely done and compiled on blue. Only at the end of this process do I flip a switch in Jenkins so that the application now points to the blue environment and no longer to green.

As a result, downtime dropped, security risk is low, and we have control. I am deterministic, and I can execute the same process N times. There are many gains and many benefits. That is what I am describing from back then. Today there are many other features and resources in Jenkins that we use here. You can also integrate Terraform and Ansible with it, and then the sky is the limit.

Regarding approximate metrics for Jenkins on CentOS 10, the change in deployment time is huge. Over the years, applications get more complex and bigger, and the modified files become numerous. Doing deployments manually and compiling externally is risky, and doing it via FTP or even via rsync with tar.gz ends up taking time. We had deployments that took over 20 minutes, and with this structure, it dropped to around five minutes, which is much shorter.

Production incidents were even worse with the old builds because we wrote code to the application on the fly. While users were using the application, we were updating the code. That created many risks and problems, including calls to routes that did not exist yet. In our telemetry, we would see errors such as user A trying to hit route X that did not exist yet. That meant a version of the code that already called a route went up, but the route file had not been updated yet. They would try to call route X, route X would not exist, and then we had countless errors and the screen froze for the user. Imagine this in your checkout flow: the client is making a purchase, and during the process you perform a build. That build ends up killing that checkout, and the risk of financial loss is high.

I remember that the error rate in our telemetry system more than doubled. If we had an average error rate in the application of, I do not know, 5% of the traffic, it would go up to 20–30%, and these errors were all false positives. Of course, after the build finished, things normalized, but we had about 20 minutes like that.

Among the best features Jenkins on CentOS 10 offers, the ones I use the most are the versioned pipelines and the Shared Libraries. As you start versioning lots of pipelines, you sometimes copy code snippets from one pipeline to another because they perform something that another job executes. It is similar to software development, where you have controllers that play the same role for a given feature. Sometimes you have to copy a controller to another feature because that feature will use a similar controller. With Shared Libraries, I do not need that. I can have one controller and call it in other pipelines as well. I declare it in Jenkins, indicate the repo where it is, and any pipeline that wants to use it just needs to call that method, because when you start the build, it already loads into memory what you need to use. That is really cool.

Besides that, I already mentioned in the previous question all the other benefits I appreciate about Jenkins. For example, JCasC, which is Jenkins Configuration as Code, is a great feature. It can provide more security to your flow, your control, and your infra team, which sometimes controls everything regarding what is installed, which server it is, how it is on the network, and who has permission. If you already have that versioned in a controlled repository, where the infra team that manages it is in charge, it can provide the team with a lot of security and ease in server migrations as well.

Shared Libraries impact our day-to-day work and collaboration between teams in a very practical way. Imagine that in your development organization, you have several teams working on different products, and the pipelines are all versioned in the same Jenkins project because for some reason they are part of that product. It is one product with N applications, and each application needs its own deploy. All these pipelines are versioned in the same repo.

Let's say you created a Shared Library for application A. This Shared Library has N functionalities that help you in your pipeline, such as compiling a given project in a given version, creating a .env file for a particular project, building, searching, creating quality gate execution systems, and handling the servers you need to rsync or not. Then another team that did not create that Shared Library needs something similar. The time that Team A took to implement that entire Shared Library, Team B would also have to spend. Since you have already versioned it, they just need to call the library they need, use the methods that make sense for them, or even add new methods to those Shared Libraries that might make sense for that pipeline. That is case by case, but it can help the teams a lot in their day-to-day work.

As I said, you end up reducing code duplication between pipelines. Instead of using Ctrl+C and Ctrl+V, you just call a method. Another benefit is that if a given method needs to be updated, the other pipelines will not need to be adapted. They automatically get that code improvement or bug fix, because they are not duplicating code; they are calling a Shared Library that is wired into all the pipelines that use it.

Regarding additional features of Jenkins on CentOS 10, Jenkins does not only have these features. Since this is a slightly quicker chat, I am mentioning the ones that make the most sense to me and that best solve my day-to-day issues. Jenkins covers every kind of need.

For example, the pipeline itself has two ways you can define how you will implement it: a scripted pipeline or a declarative pipeline. It depends on what you understand and what you think is best for your application and your team. Jenkins has N features and can have N capabilities for you. That includes plugins: there are several third-party plugins and plugins maintained by the Jenkins project itself and by CloudBees, one of its main contributors, that help in day-to-day work. I use several plugins where Jenkins, out of the box, does not cover what you need, so you need to build it out according to your needs and look for the tools it offers you according to those needs as well.

Regarding how long I have been using Jenkins on CentOS 10, I need to make a correction, since you are suggesting that Jenkins was installed and is running on CentOS 10. CentOS 10 is very recent. I do not even use it here yet; we still use CentOS 9. In any case, I have been using Jenkins for about 11 or 12 years. Actually, I might have been using it for even longer, but I cannot give you the exact time. It is 12 years for sure.

I have already used it on Ubuntu, Debian, and CentOS. However, I use it a lot on Oracle Linux, the more recent versions, mainly for security reasons. But for a long time, it has been about 12 years now.

I have been using Jenkins on CentOS 10 for approximately seven to eight years.

My main use case for Jenkins on CentOS 10 is to run CI/CD pipelines.

To run my pipelines using Jenkins on CentOS 10, we have different applications where the whole build, test, deploy phase is run through pipelines, as well as other configuration that are applied to the applications.

I haven't observed anything truly unique in how we interact with Jenkins on CentOS 10 as I've seen more or less the same use case in other companies.

The best features Jenkins on CentOS 10 offers include many plugins that you can get from the community, so it's highly adjustable to the environment, supports multi-branch pipelines, has an architecture of primary and secondary servers for scaling up Jenkins that works really well when you have larger teams using it, and also has many native integrations with Git, Bitbucket and so on, making it excellent overall.

The plugin ecosystem and scalability of Jenkins on CentOS 10 have specifically helped my team because it's really beneficial when you can use additional secondary servers, and it scales well because of that; I use dozens of plugins for authentication, building role-based access control in larger teams and so on, as well as a bunch of pipeline improvements.

The plugins related to the integrations in Jenkins on CentOS 10 are crucial because many of them allow integrations with different systems.

Jenkins on CentOS 10 has positively impacted my organization by allowing our teams to build and deploy applications really fast, and because it has been around for many years, it's easy to find people with good knowledge in Jenkins who can immediately start contributing to the team without having to learn some new tool.

Deployments are at least eighty to ninety percent faster using Jenkins on CentOS 10 compared to scripting your way and developing your own tools, so the time saved is enormous as well as all the cost that comes with it, which otherwise equals additional cost in engineering time spent.

The plugins in Jenkins on CentOS 10, while really great because of the huge ecosystem, can also be a pain point because you never know how long they will be maintained, and there's a slight instability there; if you depend on some plugin that does an integration with some product and the plugin is not maintained anymore, you're blocked from using the product features that would integrate through the plugin, and it doesn't have high availability natively.

I have been using Jenkins on CentOS 10 for approximately seven to eight years.

Jenkins on CentOS 10 is stable.

Jenkins on CentOS 10 can scale well by adding additional servers.

There is no customer support for Jenkins on CentOS 10 since it's open source.

I haven't switched from another solution, but I have used other solutions in parallel.

I have seen a return on investment in terms of time saved and money saved because of the time saved for engineers, but I don't have any specific data that I would be able to share.

At some point, I evaluated CircleCI alongside Jenkins on CentOS 10.

My advice for others looking into using Jenkins on CentOS 10 is that it costs nothing, so give it a try; I'm pretty sure you will find it easy to use. I don't believe there are any improvements needed for Jenkins on CentOS 10 that we haven't discussed yet.

I used Jenkins on CentOS 10 for three years, primarily for pipeline automation and unit test control.

My main use case for Jenkins on CentOS 10 is pipeline automation and unit test control, where pipelines were configured directly through the Jenkins interface, and the unit tests for the applications were scripted and configured.

I use pipeline automation and unit test control in my daily work with Jenkins on CentOS 10, where Jenkins was installed on a Windows platform and it delivered to Kubernetes environments.

Jenkins on CentOS 10 has had a positive impact on my organization by making delivery routines easier, avoiding errors and rework.

This facilitation of deliveries helped my team in day-to-day work by providing delivery metrics, with successful and failed deliveries, and it also made the rollback process easier in case there was a failed delivery.

I believe that Jenkins on CentOS 10 offers the best features with the execution of pipelines and the archiving of artifacts from the tests and from the delivery itself.

Regarding pipeline execution and artifact archiving, I consider that it basically runs the same as other CI/CD managers, but it’s a very important product in the market, with plenty of documentation, and it’s easy to work with.

I believe Jenkins on CentOS 10 could be improved by updating its interface, making it a bit more intuitive and modern.

I have been working in my current field for approximately 20 years, and I have used Jenkins on CentOS 10 for three years.

Jenkins on CentOS 10 is stable.

The scalability of Jenkins on CentOS 10 is good, and it’s easy to scale.

Previously, there was no automation for application delivery, and Jenkins on CentOS 10 came in to provide this automation.

I have seen a return on investment in terms of time saved and fewer delivery failures.

I didn’t have any costs with Jenkins on CentOS 10 as I used the community version.

Before choosing Jenkins on CentOS 10, I evaluated Azure DevOps.

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

I rate it an eight because it serves its purpose well, although it has a slightly outdated interface.

I would advise others who are thinking about using Jenkins on CentOS 10 to study the documentation thoroughly to perform a clean and straightforward installation.

My main use case for Jenkins on CentOS 10 is CI/CD, Continuous Integration and Continuous Delivery, where I have pipelines to produce builds, test the artifacts, and eventually do the release.

Jenkins on CentOS 10 supports my continuous integration and continuous delivery process through the pipelines, where we run both unit tests and the regression chain, and eventually we get the verdict on the delivery quality for a potential release of that artifact.

Jenkins on CentOS 10 is the main orchestrator that currently helps us ensure, in an automated way, the quality of the product we are delivering.

Jenkins on CentOS 10 has positively impacted my organization by automating a large part of our deliveries, from generating the product build to the tests and eventually the delivery of the artifact.

This automation has impacted the team's results by providing more capacity for the teams to deliver. Things that used to be manual are now automated in Jenkins pipelines, allowing the team more free time to develop and implement things that really matter and add value.

The best features that Jenkins on CentOS 10 offers include flexibility, as both scripted and declarative pipelines are very flexible and allow us to have anything from the simplest to the most complex implementation of a given pipeline.

Regarding the flexibility of the pipelines and scripts, we have stages that run conditionally, depending on the artifact that is being built. This facilitates our projects and brings clear benefits to the team with a lean pipeline, as it does not necessarily run all the stages that might be redundant or unnecessary for that specific artifact.

The features of Jenkins on CentOS 10 are enhanced by the possibility of having several agents running and calling them through labels so that they are categorized. For example, for a given artifact I use agent X, and for another artifact I use another agent. This helps a lot. In addition, there is the possibility of having plugins integrated into Jenkins and into the pipeline, which makes everything much more powerful and flexible.

I give Jenkins on CentOS 10 a score of 8 because I see that some plugins are maintained by the community and are not actually supported by Jenkins. Jenkins could, in some way, have native integration with the main build and test tools, and so on.

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

Jenkins on CentOS 10 is quite stable.

The scalability of Jenkins on CentOS 10 is relatively easy, as we add agents as needed and on demand, allowing us to scale agents up or down according to demand.

We have basically relied on community support for some occasional issues, which are not many, I must say.

We have already obtained a return on investment, as the lead time for deliveries ends up decreasing because the time that people from development teams previously spent doing manual tasks is now automated, allowing them more time to actually implement.

This automation is not only less error-prone for humans but also provides more free time to implement things that add value to the product.

On a scale from 1 to 10, I would rate Jenkins on CentOS 10 an 8 overall.

My advice to others considering using Jenkins on CentOS 10 is to think about the architecture and the real need before defining whichever tools are going to be implemented.

My main use case for Jenkins on CentOS 10 is Pipeline as Code, using a Jenkinsfile to handle the whole build flow, mainly for infrastructure-related matters.

I work with security and AppSec, so many tools need to be called. To avoid calling many scanning tools one by one, we wrap them in a CI/CD pipeline and use Jenkins as a kind of maestro. Snyk, Fortify, TruffleHog, Nuclei, and every other tool that performs various types of scans go into one pipeline. We configure the environment properly via GitLab and let Jenkins do its job by calling them one at a time.

Beyond what I mentioned about this use case, it adds a lot of value because we can combine the characteristics of more than one tool, since Jenkins calls all of them. This makes it much easier for us to organize how the output reaches the development team. We don't need to call each tool individually for every repository. We just include the YAML inside the repository, and Jenkins calls it, runs it, and gives us the output from all the tools at once.

Jenkins on CentOS 10 has had a positive impact on our organization. The runners aspect has been very good for helping us get organized at the company. We have a massive ecosystem with many repositories, and having Jenkins as a maestro helped us a lot with organizing the architecture. Because it has a distributed architecture, it supports distributed processing as well. The controller, which is the main node, manages the interface and orchestrates the tasks, while the other nodes, which are the workers and agents, do the work in parallel. In the past, people had to run this work manually and individually for each repository, and Jenkins fills this gap very well.

Regarding concrete results, we used to have an SLA of about two weeks to run a scan on a repository. The same repository is sometimes a microservices architecture and has other repositories inside it, so we sometimes took about two weeks just to run a scan for a single system or service of ours. With Jenkins, this dropped to just a few minutes in our day. It was a huge gain in time and SLA.

Among the best features of Jenkins on CentOS 10 is that it is multiplatform and language-independent. Since it is written in Java, it runs on Windows, Linux, and Mac, so we can compile and test projects in any stack. It is also open-source and free, so we don't have license costs. The community is huge and the documentation is extensive, which allows total customization. The Pipeline as Code aspect I mentioned is the most useful feature for us. I can build a Jenkinsfile, usually written in Groovy, and define the entire build, test, and deploy flow in a single file that is versioned within the source code.

For improvements to Jenkins on CentOS 10, I believe its plugins need to go through some reviews. It has more than 1,800 plugins that can be integrated, but we don't always have an official library of these plugins. There is no way to know whether any of these plugins might come with malware installed. We therefore always end up using only the main market plugins, such as Docker, Git, Kubernetes, AWS, SonarQube, and Slack. It would be interesting to use some community plugins as well, so it would be excellent if the Jenkins team could review these plugins.

I have been using Jenkins on CentOS 10 for a little less than a year.

Regarding stability, Jenkins on CentOS 10 is very stable.

Regarding the scalability of Jenkins on CentOS 10, it works perfectly because it supports several different operating systems.

Regarding customer support for Jenkins on CentOS 10, in the limited use I had, it worked perfectly.

On a scale from 1 to 10, I would rate the customer support for Jenkins on CentOS 10 a 10.

Before adopting Jenkins on CentOS 10, I did this work manually, which was a lot of work. I also used GitLab for a long time, but it is not an open-source alternative, which led to a very high cost for maintaining and orchestrating repositories. That is why we chose to go with Jenkins.

Before choosing Jenkins on CentOS 10, I did not evaluate other options because Jenkins is a market reference.

Overall, I would rate Jenkins on CentOS 10 a 10.

My rating of 10 for Jenkins on CentOS 10 is because it is an extremely useful tool, and before it, this orchestration work was very difficult and practically didn't exist. There are other tools that try to do something similar, such as GitLab, but they already require payment and are more of a platform as code, whereas Jenkins offers an open-source option.

Regarding the governance and security of the AI features in Jenkins on CentOS 10, I think it is very good, based on the little I tested. I tested some prompt injection functionalities to see if it would fall for them, and the guardrail worked perfectly.

Regarding the accuracy and reliability of the AI features in Jenkins on CentOS 10, in my use, it produced very reliable results in the plugins I used and in orchestration as well. Since I use it for security tools, I constantly have to review things, and all my reviews went perfectly. I didn't have any kind of bottleneck with the AI.

Jenkins on CentOS 10 is deployed in our organization on a local cloud.

My recommendation to others reading reviews on PeerSpot who are considering Jenkins on CentOS 10 is to use it without fear, because it is open-source, very reliable, and has a huge community working on it.

I mainly use Jenkins on CentOS 10 for deployment, performing deployments, and rolling out to dev, QA, staging, and production environments.

First, the application is built based on the image that is on GitHub, and we roll that image out to our environments. Our pipeline runs the tests, performs the build, checks test coverage, and runs the whole code quality process. In the end, it pushes the application to the environment where it is supposed to go.

The best features that Jenkins on CentOS 10 offers are the use of scripts and the deployment automation.

Each application requires a specific configuration, and having the freedom and flexibility to change and code the behavior of each pipeline is essential.

Jenkins on CentOS 10 has had a positive impact on my organization by improving speed, as the team can roll things out without having to watch manually. While the pipeline is running, we can do other activities. The result is speed and productivity.

Based on the time we wait for a deployment and the number of deployments, I believe the improvement is around 20%.

I don't think any improvement is needed; it is already good. It already allows customization and provides logs. I don't have suggestions.

I don't think there is any other improvement that could be made to Jenkins on CentOS 10, as I have already mentioned that I am satisfied.

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

Jenkins on CentOS 10 is stable.

For me, Jenkins on CentOS 10 has always been stable. It depends on how it is configured and on the machine it is running on, and in the company where I work, it has always handled the workload.

Support for Jenkins on CentOS 10 is provided by the company's employees, so I believe it is good.

I am considering that Jenkins on CentOS 10 is not open source, because only the company's team works on it and there is no one responsible for Jenkins on CentOS 10.

Since it is something internal to the company, there is no external cost. The cost would be the time and the employees' salaries.

The choice was not mine, so it is indifferent to me.

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

I give the highest rating to Jenkins on CentOS 10 for exactly everything I mentioned earlier.

I think users should study Jenkins on CentOS 10, test it locally, create a local branch, and test it on their own machine to understand how it works, and then apply it in the company.

My main use case for Jenkins on CentOS 10 is deploying some projects.

A typical deployment pipeline for my team initially handled only manual builds, which was a little frustrating, so I tried to automate it by implementing CI/CD using Jenkins on CentOS 10 along with GitHub Actions, where I made a push to the Jenkins API to build. For the most part, I ran the tests inside GitHub, and recently I created a pipeline to test migrations and deployments using a multi-branch pipeline, which I think is the greatest example I can provide.

That covers my main use case; we also use Jenkins on CentOS 10 a lot for routines, such as scheduling some Python routines.

Jenkins on CentOS 10 has positively impacted my organization by making processes really consistent and faster, allowing us to use our time for more tasks. With all those steps and pipelines, we can do more thorough testing, which I think is going pretty well.

Although I don't have any specific numbers, I am pretty sure that releases are a lot faster now. Before, all I had to do was access the remote server, and after building on Jenkins on CentOS 10, we now only need one more step to use Docker Compose up, which we can automate when the code reaches the correct branch and passes tests.

The best feature Jenkins on CentOS 10 offers is the multi-branch pipeline, which I think is very useful for understanding how to do deployments with different branches coordinated in one job, handling all jobs and sub-jobs quite efficiently.

The multi-branch pipeline has helped my team manage jobs and deployments more easily. Instead of using the manual build, when a branch gets to development, main, or staging, they just click on build now. The process used to be too manual, and implementing this pipeline has made it work pretty well.

Jenkins on CentOS 10 also has great plugins which are very useful. I do not know all the plugins available, and I think I have more to search about them, but it is really good to have logs and histories about our builds and scheduling. This is something we might lose when using GitHub Actions, but with Jenkins we can retain it over time.

I think Jenkins on CentOS 10 could be improved with more known features and plugins because we have a lot of plugins in my organization that I do not completely understand, and we face numerous alerts and security notifications that I do not really have knowledge of.

I have been using Jenkins on CentOS 10 since I got to my actual company.

Jenkins on CentOS 10 is stable.

Regarding Jenkins on CentOS 10's scalability, I think it is pretty good; it handles our code well, and I have never encountered any significant problems.

I have not had any issues with customer support for Jenkins on CentOS 10.

I have not previously used a different solution; Jenkins on CentOS 10 was my first integration solution of this kind.

Jenkins on CentOS 10 is deployed in my organization as a private cloud solution, though I was not the one who set it up, so it is actually local on our server.

The return on investment is noticeable since we save time and need fewer people.

We do not have to assign an individual to handle deployments anymore because it is done automatically when the code gets merged and reaches the server.

Before choosing Jenkins on CentOS 10, I did not evaluate other options because I had never used any alternative before, but after starting with it, I did try to compare the differences between Jenkins and GitHub Actions.

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

I chose a nine because Jenkins on CentOS 10 is really helpful and saves a lot of time, but I deduct one point because I do not know all the features and plugins; there is still something for me to learn.

About Jenkins on CentOS 10's AI capabilities and the accuracy and reliability of output, I do not think I have used any AI features from Jenkins; my experience is limited to integrating some metric systems with AI while not using any native capabilities within Jenkins.

My advice to those looking into using Jenkins on CentOS 10 is to definitely try it out. It is a great tool to get familiar with, and once you look at the documentation and some tutorial videos, you find it very helpful, and I believe we all should use it.

For Jenkins on CentOS 10, we are mostly using it as a CI/CD pipeline to deploy our traditional applications on our healthcare platform.

Jenkins on CentOS 10 has impacted us positively, mainly because of the open-source nature. We don't need to pay for it, and we can customize it. We can run parallel jobs to reduce the amount of time taken for deployments, reducing it by approximately 40%. We run our own code and pipeline as code, and it gave us flexibility in controlling the pipelines and integrating other plugins.

Our build pipeline had multiple steps, and we identified certain steps that could run in parallel. By running parallel jobs, we were able to publish the front-end at the same time as other services, making all services available after the test cases passed. We measured this by comparing our teams' workflow. Teams were able to get changes to production by merging to a branch and publishing. We maintained that pipeline and were able to reduce our deployment times by approximately 20% compared to our manual deployments.

The best feature is the build capability, which we can optimize and customize. Customization of Jenkins on CentOS 10 is straightforward since it is open source, allowing us to easily build those components. Automations are available, and we can integrate it with Git. Docker integration is enabled, and the ecosystem is robust. Jenkins on CentOS 10 has multiple plugins available, so we can use and customize them based on security requirements. Parallel executions run effectively, and we can enable the runners and control them accordingly.

For our needs, we customize Jenkins on CentOS 10 for our builds. When we need to customize it for our own build pipelines, we write our own code and use those solutions. Plugins and integrations are valuable, particularly Docker integration and observability and monitoring integrations, which are very helpful for us.

Jenkins on CentOS 10 is somewhat dated when compared to other pipelines. I would suggest improving the build performance and using distributed agents instead of running every build on the controller. Caching the dependencies would reduce build times even further, which would be very useful. Additionally, security should be strengthened more, as we need to enforce role-based access controls and protect secrets. There are plugins that also need to be updated, as outdated plugins can create security risks. Improving the pipeline as code with the Jenkinsfile and reusing it would standardize those solutions more across projects. Enhancing monitoring capabilities to monitor CPU and agent availability would be beneficial. Automating the infrastructure to create Jenkins installations and configurations would be very helpful.

We must maintain these components and find solutions when improvements are needed.

We have not experienced significant stability issues.

We previously used a manual deployment method before switching Jenkins on CentOS 10 to a CI/CD pipeline.

Since we use Jenkins on CentOS 10 in a startup environment, it provided us with return on investment. We saved approximately 20% of the time we spent on manual deployments.

Jenkins on CentOS 10 is free, which makes it an excellent option. The cost aspect is fine for our needs.

We evaluated some options, including GitLab and GitHub Actions, but we chose Jenkins on CentOS 10 in the end.

I would rate Jenkins on CentOS 10 overall as an eight on a scale of one to ten.

From my perspective, Jenkins on CentOS 10 has both advantages and disadvantages. Based on that consideration, I chose an eight. There are areas for improvement regarding security, plugins, parallel executions, and monitoring. However, it maintains strong customizability with plugin availability and the pipeline as code function. It has valuable features that support its rating of eight.

Regarding governance and security, we have significant control. Since we customize Jenkins on CentOS 10 on our own, we must take care of governance and security. We ensure that everything remains up to date and protect against outside vulnerabilities.

Regarding accuracy, I would say more than 80% of the outputs are accurate, so we can rely on that.

We deploy Jenkins on CentOS 10 in our organization using both public cloud and on-premise solutions. For our public cloud deployments, we use Azure and AWS.

I would recommend trying Jenkins on CentOS 10 before making a commitment, as it is open source. If you want a reliable solution, Jenkins on CentOS 10 will be very useful for your deployments.

Our main use cases for Jenkins on CentOS 10 are that we run our CI/CD pipelines which are hosted in that particular Jenkins only. We use it for continuous integration and automated testing purposes, Docker image building, automated deployment, security and vulnerability checks, infrastructure automation using Ansible playbooks, and scheduled maintenance jobs such as nightly log cleaners and space backups. All of these things are configured in our Jenkins CI/CD pipeline.

The benefits of Jenkins in large-scale projects are primarily focused on CI/CD purposes. The top benefits are automation at scale where it automatically builds, tests, and deploys applications. Jenkins can use multiple agents to run jobs across different machines, which reduces the workload on the controller and enables parallel execution. Additional benefits include faster software delivery, centralized monitoring, and broad integration.

Regarding cloud integration, we have integrated Jenkins on CentOS 10 with Azure to automate application builds for infrastructure provisioning and container deployments. When a developer commits code in GitHub, it passes to Jenkins on CentOS Stream 10 where we perform the build, test, and scan. After that, we store the Docker images in Amazon ECR, and then we deploy the application from Amazon Elastic Kubernetes Services. Following deployment, we perform health checks and monitoring, which has made a positive impact.

The best features of Jenkins on CentOS 10 include continuous integration, pipeline as a code where we write code in the Groovy language and the pipeline runs automatically to perform our jobs, automation of CI/CD, the ability to schedule jobs using cron-style scheduling, access control, security, build history and logs, and Docker and cloud integration.

Pipeline functionality encompasses software delivery workflows, which involves moving software from the development or testing stage to the production server. Jenkins automates this task with the pipeline running on the CentOS Stream 10 server. The main software delivery workloads include source code management where we pull code from GitHub, building and compiling it, automating and testing it, package and containerization, and deployment and monitoring.

Regarding the Jenkins plugin ecosystem, I have used this in a product where I worked for three months. We integrated Jenkins on CentOS 10 with external tools to automate source code management, builds, testing, security scanning, Docker image creation, and monitoring without having to build every feature from scratch.

In assessing Jenkins on CentOS 10's reporting capabilities, the build duration reporting is very good, and the queue length reporting is also very good where the number of jobs determines the waiting time for execution. Additional reporting metrics include queue wait time, build success rate, build failure rate, CPU utilization, memory and Java memory heap utilization, and disk utilization.

We can benefit from reusable Jenkins file templates and shared libraries so we do not need to write them repeatedly. We can enhance build efficiency with caching dependencies and reusing artifacts. Additionally, we can back up the Jenkins on CentOS 10 configuration and test restoration for reliability. During deployment, we can add more advanced health checks and rollback procedures. Regarding cost optimization, we can improve resource usage by staying within appropriate size limits and using ephemeral build agents.

We have been using Jenkins on CentOS 10 for four years.

I have not faced any crashes or performance issues with Jenkins on CentOS 10.

I find Jenkins on CentOS 10 to be scalable.

We use only Jenkins. In another project, I worked for three months where we used GitHub Actions.

The setup of Jenkins on CentOS 10 is straightforward.

In comparing Jenkins on CentOS 10 with GitHub Actions, Jenkins offers self-hosted and managed setups, while GitHub Actions is only GitHub-hosted. Jenkins requires installation and maintenance when self-hosted, whereas GitHub Actions is easy to start within a GitHub repository. The configuration files also differ as Jenkins uses Groovy-based configuration while GitHub Actions uses YAML language.

Jenkins on CentOS 10 is a very good tool for DevOps because it is an established tool with strong CI/CD capabilities. I highly recommend using Jenkins on CentOS 10 for CI/CD purposes. I have rated this product with a review rating of ten out of ten.

I primarily use Jenkins on CentOS 10 for managing complex build pipelines and ensuring smooth deployment automation. It helps us streamline our continuous integration and continuous delivery processes.

Recently, I used Jenkins on CentOS 10 for a major release where I needed to integrate numerous microservices and ensure seamless deployment. Jenkins on CentOS 10 played a key role in automating this, from testing to deployment, which saved us a lot of manual effort and time.

Jenkins on CentOS 10 automates several processes, particularly in our CI/CD pipeline. It makes the work much easier by automating testing, builds, and deployments, which significantly reduces manual intervention and errors.

Jenkins on CentOS 10 has made our organization more efficient and reliable. By automating repetitive tasks and reducing manual errors, we have saved time and resources, which we can now allocate to more critical tasks.

Jenkins on CentOS 10 has helped my team in Belgium with faster deployments and improved tracking of our software lifecycle. It has enhanced our overall process efficiency and product delivery timelines in the Belgian office.

I really appreciate the integral pipeline management features and desktop integration options that Jenkins on CentOS 10 offers. These make managing various tasks and processes very streamlined and efficient.

The pipeline functionality in Jenkins on CentOS 10 is valuable because it provides a comprehensive view of the entire build and deployment process, and it allows us to automate and monitor every step efficiently. This visibility and control enhance our workflow management significantly.

Stability in Jenkins on CentOS 10 could be enhanced. We look forward to improvements in the user interface and performance optimizations. Enhancing integrations with other tools would also be beneficial.

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

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

I give Jenkins on CentOS 10 a perfect score for its reliability and the extensive features it offers. Additionally, the way it manages CPU usage efficiently is a big factor for us.