Jenkins Reviews

This solution is open source and we use it for the entire bill pipeline - for building different languages, for running reports on code coverage, running our QA tests, automated tests, and for deployment. We are customers of Jenkins and I'm head of infrastructure. 

The advantage of this product is that it brought automation to the company. Instead of manually billing, manually trying to run tests, it now happens automatically. 

The best thing about Jenkins is that it's such an open community, and it has a bazillion plugins which is a neat feature. Anything you want to do, someone else has probably already done it.

Despite there being a whole lot of community input on the solution, nobody is providing professional services around it. Jenkins itself is a very small company but it would be great if they could host and offer some kind of SaaS product which would provide an organizational structure of some sort.

I've been using this solution for 13 years. 

Stability is not top notch but it's pretty good. 

The solution is very scalable, I probably have around 60 people using it, mainly developers checking whether there are any errors. We have around 10, 15 QA people, power users, and  another 40, 45 developers looking at it. The solution is being extensively used but we only need one person to deal with maintenance. 

The initial setup was straightforward and didn't take too long, maybe a few days. Implementation was carried out in-house.

It's important to take the time to research the solution and find what's right for you. Since it's so customizable, there's a million ways to do things and since there's no professional services that says this is the right way, you have to figure it out on your own. Take that time, do the research, try things out. Make sure it works before you go ahead and put it into your whole organization. This solution touches the bases of everything we need to do. Professional services aren't there, but that's the only downside. Other than that, we're very happy with the product. 

I rate this solution a nine out of 10. 

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.

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.