Jenkins on CentOS 10 Hardened

Within our day-to-day workflow, the pipelines run on Jenkins on CentOS 10, and we create the end pipeline artifact for the application.

Rather than just faster work, I think the biggest improvement is that Jenkins on CentOS 10 has more features.

In practice, for my team on Jenkins on CentOS 10, making releases more reliable is more important.

In terms of time savings and manual work, Jenkins on CentOS 10 requires less manual work for the build.

The feature I find most valuable in Jenkins on CentOS 10 is automation. I think automating the build and deployment pipeline is more important for me.

Jenkins on CentOS 10 is also important for automating jobs that would otherwise be manual.

To clarify, I have not just started using Jenkins on CentOS 10. I am saying that I currently use it.

We have been using Jenkins on CentOS 10 for more than two years.

In my personal experience with Jenkins on CentOS 10, I use it for more.

For Jenkins on CentOS 10 specifically, I have used it for more than two years.

I use Jenkins on CentOS 10 mostly to run my automated test pipelines, which are integrated with the deployments that the development teams perform when they deploy their applications. I use it mainly to create and run my automated test stages, either post-deploy or scheduled within Jenkins on CentOS 10, so that the tests are executed every day during a period agreed upon with the team and within the squad.

In my day-to-day work with automated test pipelines, I usually already have a DevOps team in the companies where I work. This DevOps team creates a QA profile for us and provides the machines that we can use.

Generally, we configure Linux or a virtual machine inside Jenkins on CentOS 10 and do all the setup, running Linux and installing the programming languages used in the tests, whether Java, JavaScript, or others. In these configurations, we also add reporting plugins so that we can later have a report of our tests within Jenkins on CentOS 10. We use many configurations, and I, in particular, try as much as possible in my workday to explore Jenkins on CentOS 10 and what it can offer me.

Today we also have AI assistance integrated with Jenkins on CentOS 10, including AI agents that we can use to make our daily work easier, more automated, and more optimized with Jenkins on CentOS 10.

I mainly use it for automated testing. As I mentioned, these automated tests run either post-deploy from a developer or on a schedule within Jenkins on CentOS 10, so that they run every day. Jenkins on CentOS 10, together with AI, can send the reports in an alert, whether by email or through a communication tool such as Slack, which has a nice integration with Jenkins on CentOS 10. Those are all the conveniences I use within Jenkins on CentOS 10.

The positive impact on our organization is in anticipating errors in production. My tests are set up so that I do not need to worry about monitoring Jenkins on CentOS 10 all the time.

After my tests finish, Jenkins on CentOS 10, integrated with a communication tool such as email or Slack, sends us an alert with the result. If there is any bug or error, we can deal with it as soon as possible so that the product in production does not suffer damage or revenue loss, and so that it does not impact the company's revenue. This is the biggest impact that Jenkins on CentOS 10 has on my day-to-day work.

The impact I can quantify is the time saved, because while Jenkins on CentOS 10 is running the tests, probably within the tool itself, I can be doing other things in my daily work. With AI now, I can do more than one thing at the same time, so this is very fast. I would say that Jenkins on CentOS 10 contributes to 60% of the quality of my deliveries.

Jenkins on CentOS 10 offers many great features, and I have already mentioned all the ones I use. The AI integration feature is essential today. I no longer need to code my Jenkins on CentOS 10 pipeline in a Jenkinsfile inside my code, as it used to be done in the past. Today, we can do all the configuration in the graphical interface, and I use the graphical interface of Jenkins on CentOS 10 a lot. What I like the most and have always used is job scheduling.

These are the features in Jenkins on CentOS 10 that I like and use the most in my daily work: the pipeline, configured directly in the graphical interface of Jenkins on CentOS 10 without needing a Jenkinsfile; the AI; and the scheduling, where I can leave my automated tests scheduled and Jenkins on CentOS 10 does the rest, running everything within the tool itself. I think these are the main features that I use.

Today it is very aligned with AIs, especially Jenkins on CentOS 10, which comes with this AI capability. I think Jenkins on CentOS 10 is cutting-edge tech.

It could have an easy-to-use mobile app so that the company can solve problems without needing to be at a computer. Sometimes, during a meeting, you could open Jenkins on CentOS 10 through a mobile app and see the results. A Jenkins on CentOS 10 mobile app, an app to be used on mobile devices, could also be useful for users.

One thing that Jenkins on CentOS 10 should improve, although AI is available via plugins, is native AI. A native AI agent directly inside Jenkins on CentOS 10 would be nice.

Today, it works with the companies that provide us AI agents, such as AWS, OpenAI, Llama, Bedrock, and all the others that provide them, and we can use their AI. Jenkins on CentOS 10 gives us the flexibility to use the AI plugin we are most familiar with, which I think is great.

I first need to ask: Jenkins or Jenkinson? I have been using Jenkins on CentOS 10 for a while now, for all the projects I have worked on. I have been using Jenkins on CentOS 10 for between 12 and 15 years throughout my work journey.

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

I gave Jenkins on CentOS 10 a nine because nothing is perfect. I think 10 is too much, because everything, especially when dealing with technology, tends to improve. Nine is the ideal number at this moment for everything it offers us. I did not give it a 10 precisely because everything tends to improve more and more. That is the main reason I gave it a nine.

I do have thoughts on the governance and security of the AI features of Jenkins on CentOS 10.

Jenkins on CentOS 10 is deployed in a private cloud within the company. It is hybrid, partly public and partly on-premises. All control of Jenkins on CentOS 10 is held by the DevOps team, and its deployment is done by this team, so it is very secure. For example, if we work remotely, we need to access it via VPN, which provides more security so that our applications do not become public, with sensitive data and our code becoming public, and so that there is no intrusion.

For the hybrid architecture of Jenkins on CentOS 10, it depends: one part is from Google, and another part is Amazon AWS. The company uses both providers.

For anyone thinking about using Jenkins on CentOS 10, the pronunciation is Jenkins. My advice is to use it and explore it. It is a secure tool with the flexibility to integrate with several companies that provide AIs, so you are not tied to just one, but it would be nice to have its own AI agent as well. It has easy usability. Today it does not need to be configured via a Jenkinsfile, as I mentioned. Through the graphical interface on the screen, you can do your configurations within your pipeline and your stages.

It has become much, much simpler to use, which is important because it optimizes time. My advice is to use it and take advantage of it, because it is an excellent CI/CD delivery tool.

My main use case for Jenkins on CentOS 10 is building and containerizing our applications. I use Jenkins on CentOS 10 to make the builds and to create Docker containers. I push these containers to Elastic Container Registry and publish the Docker containers in the cloud.

Jenkins on CentOS 10 fits into our whole pipeline and makes all of these things possible. I run my tests in Jenkins on CentOS 10. I have Jenkins on CentOS 10 linked with my GitHub, and it starts the whole process: it makes the build, runs the tests, and finally, I can publish my system in the cloud, in the current cloud.

Jenkins on CentOS 10 has positively impacted my organization by integrating all of our CI/CD processes. The most important aspect for my organization is the capacity of Jenkins on CentOS 10 to integrate all CI/CD processes for testing and development, and all of it is free. It is very useful, very adaptable, and awesome for us.

Jenkins on CentOS 10 has produced clear outcomes in how we deliver and save time. It saves my team a big amount of extra time for now, because the developer does not need to watch the process. It is totally automatic, and the deliveries are very fast.

The best features Jenkins on CentOS 10 offers are the webhooks and its integrations. The webhook is very important for me, as is the integration with other systems, with all systems: Bitbucket, GitHub, Amazon Web Services, Google Cloud, and Oracle Cloud. This integration is amazing, and it is very easy to use.

Jenkins on CentOS 10 has made our day-to-day build and release work much easier and much faster. I have set up parallelization of work, and many teams want to work with one instance of Jenkins on CentOS 10. I do the work and centralize the resources in one stack for all requests, and it works all day very easily and very powerfully.

Jenkins on CentOS 10 could improve build and integration times, even in small ways. The main area is time: the build time, the construction time, and the continuous integration time, because my team would have more time for other things.

I rate Jenkins on CentOS 10 that way because I think it could be faster, more beautiful, and more useful. Perhaps one alternative for the application is possible in this way.

I have been using Jenkins on CentOS 10 for about five years. I have switched between Jenkins on CentOS 10 and other kinds of solutions, such as Amazon CodePipeline and CodeBuild, but Jenkins on CentOS 10 is awesome. It is very useful, it is free, and my team uses it for compiling, for testing, and for their work.

Jenkins on CentOS 10 is stable in my experience. It is awesome.

Jenkins on CentOS 10 scales very well, in my view. It is very good, and the configuration is very easy.

I have had no need to use it for now, but I am sure it is very good too.

I use Jenkins on CentOS 10, and maybe in the future, I will use it more.

We have seen a return on investment with Jenkins on CentOS 10, and the main metric is people's time. In the ROI, the time of people is the main factor, because the time of people is money rollback.

I estimate that Jenkins on CentOS 10 saves my team about five hours per person each week.

Our experience with pricing, setup cost, and licensing for Jenkins on CentOS 10 has been good for virtual machines. For virtual machines, it is good and cheaper than Amazon. If Jenkins on CentOS 10 in the future made one cloud service at the center of the organization, I think this would be a very good idea.

I had no need, because Jenkins on CentOS 10 is wonderful.

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

The governance and security of Jenkins on CentOS 10's AI capabilities is a very important topic. I am securing the whole system and the whole cloud for now. I think Jenkins on CentOS 10 gives the possibility of making one MCP server, because not all people should have access to the configuration, but it is very important to have the possibility of rating almost all of the configuration and the process.

I have no idea about the accuracy and reliability of Jenkins on CentOS 10's AI output, but automatic configuration and one point of connection coming from Terraform are very important to make new configurations faster.

For now, it is an excellent solution.

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.

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.