Jenkins Reviews

We used Jenkins for integration purposes, primarily for integrating with version control systems like Git and build tools such as Maven. Later, there were plans to use it in Docker deployment for Docker containers. 

I configured environments for non-production, production, and development in the pipeline. 

I also used Jenkins for a Bluegreen deployment strategy, quality assurance with SonarQube, and artifact storage in JFrog Artifactory.

In our previous company, Jenkins was used for complete automation of build and deployment in a project. From part of automation and customization, I was involved in the project.

The most valuable feature of Jenkins is the plugins available. You name any tool, and there is a plugin available for it in Jenkins. 

Also, the ability to customize these plugins is valuable. Its user-friendliness stands out, especially in its user interface which allows easy installation and configuration.

Jenkins could improve in areas related to Kubernetes and Docker container integration, like machine allocation of nodes and Marshaling integration improvements. Making these aspects more robust would be beneficial.

I have been using Jenkins for around five years now.

Jenkins is stable. Any tool can have latency of a few seconds, but I would rate Jenkins four and a half out of five for its stability.

Jenkins is not as scalable compared to container solutions like Docker or Kubernetes. While it can be configured at the server end, the other solutions offer more robust automation and scalability.

My team handles technical support for Jenkins when necessary. However, since I moved into AI and machine learning projects, I haven't been closely involved with technical support issues.

Positive

The initial setup of Jenkins is very straightforward and not difficult.

By installing Jenkins in a master-slave environment, there is significant cost saving, making it a cost-effective tool compared to other CI tools.

I do not have extensive knowledge on the pricing or licensing aspect as I used Jenkins for free at the local machine level. However, it is generally regarded as cost-effective.

I would rate it a nine out of ten.

We use Jenkins for the continuous integration of our jobs and products. We do have a couple of jobs that were created through Jenkins, and it's logical to start like that, as it requires the Java framework to run on Jenkins. We have the developer code; we begin with the power and the PSQL. 

I like the business logs. It's a very useful tool. Client-server communication is also very fast.

It would be better if there were an option to remove its Java dependency. This would make it more compatible with other software, and it could be much better. At present, we have to depend on Java whenever we want to deploy agents.

I have been using Jenkins for about two years.

Jenkins is a stable product.

Jenkins is a scalable product. 

The initial setup is straightforward.

I would tell potential users that Jenkins is a very good tool, which I highly recommend. It's very helpful for the continuous integration of any products. For example, if you want to dial up some things on production and want to go live, we can continuously integrate them. We can put it onto the report starting from the no-code and the subsequent environment and letters. So, Jenkins is very highly recommended.

On a scale from one to ten, I would give Jenkins a ten.

We are using Jenkins to automate the compilation and check the implementation from scripts for validation and testing. It's a useful tool for any developer.

If the code works fine in the company's development environment, it doesn't mean that it will be okay for other platforms. We're using Jenkins to test the server in platforms. It's very helpful.

Jenkins has improved our organization by allowing us to use automatic testing to cover all the various levels of software, which includes software embedded into hardware. It has been very difficult to be able to run tests in embedded software in the past.

The most valuable features of Jenkins are the integration of automatic scripts for testing and the user's ability to use any script.

Jenkins is not an easy solution to use and the configuration is not simple. They can improve the solution by adding a graphical interface that is more user-friendly.

I have been using Jenkins for approximately one year.

The stability of Jenkins is good.

Jenkins is scalable.

We have five people that are using this solution in my company.

I have not used the support from Jenkins.

I did not use a solution other than Jenkins.

Jenkins is complex to implement.

The implementation of the solution was done in-house. We use two or three people for the deployment.

The solution has had good value for the money we spent.

My advice to others is this is a tool that will help save time have good coverage for the validation environment and test more hardware capabilities. For example, it can handle an embedded system and it can run any type of script.

I rate Jenkins a nine out of ten.

We use Jenkins to remove human error when completing multiple deployments. 

The most valuable aspect of this solution is that there are multiple features. We can abstract certain variables and then build our deployment routine while being able to do some abstraction onto the SSH connections. 

We can access a history of the different deployments so that we know whenever we have an issue. Problems are well documented so we can actually go back into your deployment history when necessary.

This solution could be improved by removing the storage of unnecessary data such as the history of test deployments that were unsuccessful. 

In a future release, we would like to have access to more third party plugins and would like to integrate with tools like Kubernetes.

We have been using this solution since 2014. 

This is generally a stable solution. Sometimes we have experienced some issues but they have been minor. 

We have previously used an FTP server and we would copy and paste the files manually. I still prefer to use Bash scripts directly and deploy using SSH, or there are situations where we will not use an application because it would be overkill for such a simple deployment. We continue to use alternatives alongside Jenkins because sometimes it is pointless to build an entire Jenkins job just for deploying a website.

There is a learning curve at the beginning. Jenkins could have setup wizards that could help you start off instead of having to rely on someone, reading a manual or completing an online tutorial.

We've done everything in-house. 

We use the open source solution.

There might be unnecessary overheads if you're trying to use Jenkins for very simple deployments. I would say make sure that you actually need to use Jenkins for specific actions.

I would rate this solution a ten out of ten.

We use this product as an open-source CI/CD. It allows integration, building pipelines, and even linking them to Azure or AWS platforms. It is an open-source tool. However, I wouldn't call it a public cloud. I would refer to it as an open-source tool for continuous integration and deployment. It can be integrated across every platform.

Our primary use case for this solution is creating pipelines for some projects we work on. Additionally, we use it to build pipelines and provide them with commands. For example, if we want to make a Docker image or send the deployments to Azure then we can integrate them into the Jenkins app service instead of Azure DevOps.

The user interface could definitely be improved, and I rate it close to zero. It isn't very good, and I am sure why it has not been worked on. The user interface could definitely be improved.

We have been using this solution for approximately a year and a half and are currently using the latest version.

The solution is stable but it is slow. It is a free service so I can't complain about the time it takes.

The solution is scalable and concurrent users have access to the platform. Currently, only a few people in our company are using this product.

I have not contacted customer service and  support.

The initial setup was difficult. It is not easy to comprehend, and I recommend having a hands-on tutor or experience for you to be able to use it effectively. Additionally, the documentation is not helpful, as it is not user-friendly. I am unsure if this is because it is an open-source product, but it can definitely be improved.

It took approximately two hours to set up from scratch. In order to create the Docker image dependencies that need to be integrated need to be checked. The required keys also need to be identified because some SSH keys might be needed.

We chose this solution because it is in line with the budget and customer preferences. 

I rate this product a four out of ten. I would advise people using this product for the first time to review the provided documentation and watch some YouTube videos on the setup process while trying to understand the platform itself. The documentation is essential as it allows for a better explanation of some features and YouTube assists with troubleshooting. The product is affordable, but the user interface needs to be improved.

Jenkins is basically used as a CI/CD tool, wherein you can integrate multiple tools that are part of your delivery pipeline. Jenkins is basically a controller for your delivery. For example, what happens, when it happens, and in what sequence it happens can be controlled by Jenkins.

Jenkins is a very mature product. 

It has got a lot of support as far as integrating Jenkins with other tools is concerned. 

There are a lot of plugins as well if you want to enable any feature or any automation as part of your delivery pipeline. There are a lot of plugins, actually, which are available both as part of an open-source as well as a commercial ecosystem.

It is easy to configure and easy to scale as well.

The initial setup is easy.

The enterprise version is less stable than the open-source version. 

Security is one area that is lacking a bit. You need to have that extra work done when you are adopting Jenkins. There are some features here and there, however, if security overall can be improved, that would be really great.

I've used the solution for more than ten years. 

The solution is stable. It's reliable. There are no bugs or glitches and it doesn't crash or freeze.

It is scalable. Jenkins can be implemented in a master play mode. You can have multiple masters and you can have multiple notes on which you can execute your jobs, which makes it very scalable.

We have about 500 people using Jenkins.

We've never contacted external support. We've only dealt with internal support. Internal support is very well educated in terms of supporting Jenkins and other tools of concern. I'm very satisfied.

Jenkins was the first product I used. Apart from Jenkins, there are other tools I've used, like Bamboo. Then, specific to the cloud, we have other DevOps services, and other pipelines.  I have used multiple options. Still, I'm kind of a Jenkins fan. I definitely recommend Jenkins over other tools.

The initial setup is very easy. It's not overly complex or difficult. You can enable a Jenkins pipeline, I would say, and a day, or less than a day.

We have about ten staff members that can handle deployment and maintenance. There are managers, developers, and DevOps teams, and then there are SYSops, admins, and DBAs. All these factors are there.

We handled the implementation ourselves, in-house. We didn't need any integrators or consultants.

One good thing about Jenkins is there are two flavors. One is open-source and the other is the commercial or the enterprise edition. The open-source version is pretty stable. For the security concern, you can add your own security-related intervention to make it that much more secure.

For the enterprise edition, you have a cloud-based which actually provides the commercial Jenkins version. Apart from security, they have come up with upgraded versions of Jenkins, for example, Jenkins Access Control and Jenkins Two-point Access Control. You can get added all kinds of features and the ease of implementing or managing your product. As I mentioned, Jenkins open-source is actually more stable and mature if you compare it to the enterprise version.

The solution can be on-premises or in the cloud. 

I'd recommend the solution to others.

I'd rate it ten out of ten.

We use Jenkins to trigger the URL and necessary files in a batch. Jenkins is integrated with Jira and Litmus. We'll put a URL into Jenkins and trigger it. We can schedule it to run overnight every day, week, month, etc. 

Multiple teams are using Jenkins, and it's integrated with multiple Jira plugins. I believe around 250 people using it.

We can schedule anything with Jenkins, which is useful for deployment or anything that requires scheduling. It also has multiple plugins we can use for Maven, JUnit, etc.

Jenkins could have better cloud functionality. Currently, we are using the existing legacy model, but we are moving toward the cloud, so it would be great if they could improve in that area. In the future, I would like more cloud features and related training materials, like a video tutorial. 

I've been using Jenkins for one year, and I know about related automation tools like Selenium, Tosca, etc.

Jenkins' main advantage over other solutions is multiple plugins and ease of setup. Open-source and secured versions are also available, so maybe that's why there are multiple processes. Other deployment tools cost more, and the setup is messy. These are some reasons management decided to use Jenkins instead of other solutions.

The Jenkins setup is easy because it's open-source, and we can get a community edition. We don't need to do anything. We only need to install it and it's ready to use. The total deployment time depends on how long you have to code. In my case, it generally takes half an hour to one hour.

I rate Jenkins eight out of 10. It's a scalable, open-source tool with multiple plugins. It's easy to use and set up. I don't rate it 10 because there is room for improvement in terms of the cloud and related capabilities. 

If somebody wants to use Jenkins, they need to first consider the scope. What is the scope, and what tech are you using? Jenkins is easy to set up, and we can integrate it with multiple technologies, whether a .NET application or anything else. We can deploy the code and can run with that. 

I use Jenkins for the continuous integration and continuous delivery phases of my pipeline. For the continuous integration part, we use GitHub with Webhook. If we have a development environment and the developer pushes anything, Jenkins will trigger the job right away. But if it is going to stage all the production environments, then Jenkins will start the job, and the developer will create a pull request. 

We can see that the test cases have passed, and the GitHub branch is ready to be merged into the feature branch. And for the continuous delivery pipeline, we are pushing things ourselves through Helm. So whenever we have to deploy something, we have created or developed our stages, through which we use Helm charts and deploy our solution.

Since we are using microservice architecture, most of our infrastructure is Kubernetes-based, which means we use docker containers inside that and cloud environments to spin up our solutions quickly. Jenkins is running inside Kubernetes, and Jenkins has some hooks attached to it. And with the plugins attached, you can spin up the container on the go whenever we have to build a job. And when the job is complete, the container is deleted. It's not like we have some node in Jenkins. The architecture comprises a master and a slave node, and you can run jobs on the slave node.

Our slave nodes work under both containers, which we are only spinning up when we need. And when we are done, we are just stripping them out instead of having our virtual machines running all the time. That is an interesting aspect of this architecture for us. Microservices waste architecture, so we use Kubernetes infrastructure with containers to spin up our slave nodes and handle the workload or the computing.

We use Jenkins for everything. We want to empower developers to have the confidence to deploy their solutions themselves into production instead of asking us as an operations guide. Even if they have to create a repository in GitHub, we have scripts behind Jenkins that can go ahead and make these for them. It's a core component of our development pipelines and developers' lives in our organization.

We used to have around 30 to 40 services, which we had to use in our microservices architecture. Now, when we have to deploy things due to the same code base, we have to write the same code every time and repeatedly in the Jenkins file. It's a monotonous job, and we cannot innovate. We are just copy-pasting the Jenkins file and only changing a few things in it. That wasn't the kind of DevOps experience we want. We want some customization instead of a mundane task. But there is an option in Jenkins called Jenkins Shared Library, where we can write our own group code. Now we are using it like a programming language in the Jenkins file.

We only have to call the object and inside that object, we have to call the function or methods we want. Our Jenkins files, which were previously 309 lines were reduced to 220 or 230 lines by only calling the objects and the specific parameters. If I want Java, I will provide Java, so it is going to call the specific stage, defining my library for Java-based code. If it is NTM, it is going to call the different libraries along with the right tools for load-based applications and testing. That was a satisfying experience. As a DevOps team, we spent a lot of time creating good value in the pipeline stream instead of spending all our time copy-pasting the Jenkins file. 

The most valuable aspect of Jenkins is pipeline customization. Jenkins provides a declarative pipeline as well as a scripted pipeline. The scripted pipeline uses a programming language. You can customize it to your needs, so we use Jenkins because other solutions like Travis and Spinnaker don't allow much customization. We can only use the declarative pipelines they provide. 

We can use Jenkins through the GUI and create customized methods. Its GUI is just like Java, so we can make our classes and define our custom methodologies. We can do whatever we want and customize as much as we wish to in any programming language. 

Jenkins is a Java-based solution, and it's a hassle to initially spin up the solution in Java. Jenkins is highly customizable through plugins, but it has limited out-of-the-box capabilities. We have to take advantage of the community configurations available to us. 

And I don't care too much for the Jenkins user interface. It's not that user-friendly compared to other solutions available right now. It's not a great user experience. You can do just fine if you are a techie, but it would take a novice some time to learn it and get things done. 

I used Jenkins extensively this whole year. Prior to that, I was using it for consolidation stuff, but this year I have used it extensively for both installations and DevOps pipelines.

There have been no crashes. I would say that the only important thing is downtime. Since it is a double application, the reboot takes a long time. It would be nice if it took less time to boot. Sometimes it takes around 5 to 10 minutes to boot with all the plugins. It would be great to reduce the maintenance time so that the developers don't even notice when it has been updated. But when we update, we need to announce downtime for that.

We have a master node, and the slave nodes are containers, so it's quite robust and scalable with that plugin for us. Even if we have a lot of jobs running at one time — sometimes it's 30 to 50 jobs running — it's cloud infrastructure. It's going to spin up automatically. The nodes are auto-scaling for the Kubernetes, and you can spin up containers on top of that, so it's quite scalable for us.

We haven't needed Jenkins support yet. 

The initial configuration with Kubernetes is a little bit clunky. Maybe we don't know how to do it because things are ever-evolving, or perhaps there is a right way that we do not know right now. This is one of the pain points. If I have to update my cluster, or there is some disaster recovery mechanism, or I have to add something in the configurations, there is no out-of-the-box tool available in Jenkins.

If I'm going to change my configurations in the conflict maps, it will not reload by itself. I have to add another sidecar container, which always looks for my configuration change updates and adds it into Jenkins. That was my pain point, and that is the same in the initial configuration part that you have to figure out. Jenkins cannot provide you with something out of the box for continuous change and updates. You have to use some third-party plugins for the sidecar containers.

The initial deployment was relatively easy because we used the UI to configure everything. Then there is one part of the configuration code in Jenkins where we have to take the configuration and put it in the conflict map. Whenever we have to change something, we only need to change the configuration map. And it reloads that part. 

The code portion of the configuration is very lengthy, and it isn't easy to figure out what should go into the configuration and what is unnecessary. There is a lot of junk in that. This is not good for the developers to put in their configuration size, but that was their end. Figuring that out takes time. That said, it's a one-person job. You don't need too many people if you know what you are doing.

After installation, Jenkins requires some maintenance, like backup and configurations. If there are some security breaches, Jenkins sends out notifications that you need to update these plugins because there were some security flaws. Sometimes we have to reboot Jenkins to apply these updates, which requires some downtime. Most plugins don't need a reboot, but we have to reboot Jenkins if it involves some core components.

We used the free version. We didn't need anything specific on the support side for that. It's totally customizable, and if you get so much good out of an open-source project, then you don't need to go for any support model. That was quite good, and community support has been good enough for us.

I looked into Travis, and I was primarily looking for customization. Travis wasn't as customizable as Jenkins.

I would rate Jenkins between seven and eight because I'm not that much of a GUI user, so I can use it. And if I have my configurations in place, I don't have to go inside and look at the UI again. It's a good solution for us.