GitLab CI vs Jenkins

Question

What is the difference between Jenkins and other CIs such as GitLab CI, drone.io, shipped with the Git distribution. In some studies, I could only come to the conclusion that GitLab Community Edition does not allow the addition of Jenkins, but GitLab Enterprise Edition does this. Are there any other significant differences?

Answer 1

This is my experience:

At my work, we manage our repositories using GitLab EE, and we have a Jenkins server (1.6).

Basically, they do almost the same thing. They will run some scripts on the server / Docker image.

TL; DR;

• Jenkins is easier to use / learn, but there is a risk of becoming a hell of a plugin
• Jenkins has a graphical interface (this may be preferable if it should be accessible / maintained by other people)
• Integration with GitLab is less than with GitLab CI
• Jenkins can be removed from your vault

Most CI servers are pretty simple ( concourse.ci ), gitlab-ci , circle-ci , travis-ci , drone.io , gocd and what else you have). They allow you to execute shell / bat scripts from a YAML file definition. Jenkins is much more pluggable, and comes with a user interface. This can be either an advantage or a disadvantage, depending on your needs.

Jenkins is very easy to configure thanks to all available plugins. The disadvantage of this is that your CI server can become spaghetti plugins.

In my opinion, linking and organizing tasks in Jenkins is much easier (because of the user interface) than through YAML (calling curl commands). In addition, Jenkins supports plugins that will install certain binaries when they are not available on your server (I do not know about this for others).

Currently ( Jenkins 2 also supports more of the "correct ci" with the Jenkinsfile and pipline plugin , which is used by default in Jenkins 2), but earlier it was less associated with the repository than GitLab CI.

Using YAML files to define the assembly pipeline (and, in the end, running a clean shell / bat) is more convenient.

The plugins available for Jenkins allow you to visualize all kinds of reports, such as test results, coverage, and other static analyzers. Of course, you can always write or use a tool to do this for you, but it is definitely a plus for Jenkins (especially for managers who tend to value these reports too highly).

Recently, I have been working more and more with GitLab CI. At GitLab, they do an excellent job, making the whole experience fun. I understand that people use Jenkins, but when you have GitLab running and available, it is really easy to get started with GitLab CI. There will be nothing that integrates as smoothly as GitLab CI, even if they put a lot of effort into integrating third-party developers.

• Their documentation will help you get started as soon as possible.
• The threshold for starting work is very low.
• The maintenance is simple (without plugins).
• Scaling down the runners is easy.
• CI is completely part of your repository.
• Jenkins work / views can get dirty.

Some benefits at the time of writing:

• Support for only one file in the community version. Multiplies files in the corporate version .

Answer 2

I agree with most of Rick’s comments, but my opinion on what's simpler is the opposite : GitLab is a great tool to work with.

Most of the features are autonomous and integrate all in one product in one browser tab: from the repository browser, bulletin board or build history to deployment and monitoring tools.

I'm using it right now to automate and test how the application installs on different Linux distributions, and just quickly configure it (try opening the complex Jenkins job configuration in Firefox and wait until the adaptive script and ease of editing .gitlab-ci.yml ).

The time taken to configure / scale the slave devices is significantly less thanks to the runner's executable files ; plus the fact that on GitLab.com you get pretty decent and free shared members.

Jenkins feels more confident after several weeks of working in GitLab CI, for example, duplicating tasks on a branch, installing plugins to perform simple tasks, such as loading SCP. The only use case I encountered when I miss it, as of today, is when more than one repository is involved; it needs to be well understood.

By the way, I'm currently writing a series about GitLab CI to demonstrate how easy it is to configure the CI repository infrastructure with it. The first part, published last week, talks about the basics, the pros and cons, and the differences with other tools: Quick and natural continuous integration with GitLab CI

Answer 3

First of all, today GitLab Community Edition can fully interact with Jenkins. No questions.

I will provide some feedback on the successful experience of combining Jenkins and GitLab CI below. I will also discuss whether you should use both or just one of them, and for what reason.

I hope this gives you quality information about your own projects.

GitLab CI and Jenkins Strengths

Gitlab ci

GitLab CI is naturally integrated into GitLab SCM. You can create pipelines with gitlab-ci.yml files and manipulate them through a graphical interface.

These pipelines in the form of code, obviously, can be stored in the code base, which ensures the observance of the “all as code” practice (access, version control, reproducibility, the possibility of reuse, etc.)

GitLab CI is a great visual management tool:

• All team members (including non-technical) have quick and easy access to application life cycle status.
• therefore, it can be used as an interactive and operational release control panel.

Jenkins

Jenkins is a great build tool. This is the power in many plugins. I was especially lucky to use front-end plugins between Jenkins and other CI or CD tools. This is always a better option than redoing (possibly badly) the dialog interface between the two components.

Pipeline-like code is also available using groovy scripts.

Sharing GitLab CI and Jenkins

At first, this may seem a little redundant, but combining GitLab CI and Jenkins is pretty powerful.

• GitLab CI manages pipelines (chains, starts, controls ...), and you can use its graphical interface integrated into GitLab
• Jenkins manages work and facilitates dialogue with third-party tools.

Another advantage of this design is the weak connection between the tools:

• we could replace any of the components of the assembly factory without the need to rework the entire CI / CD process
• we can have a heterogeneous build environment that combines (possibly several) Jenkins, TeamCity, as you call it, and yet have a single monitoring tool.

Compromise

Well, of course, you have to pay for this design: the initial setup is cumbersome, and you need to have a minimum level of understanding of many tools.

For this reason, I do not recommend this setting if

• You have many third-party tools to work with. This is when Jenkins comes in handy with its many plugins.
• you have to deal with complex applications with heterogeneous technologies, each of which has its own build environment, while still having to have a unified application lifecycle management interface.

If you are not in either of these situations, you are probably better off using only one of the two, but not both.

If I had to choose one

Both GitLab CI and Jenkins have their pros and cons. Both are powerful tools. So which one to choose?

Answer 1

Choose one in which your team (or someone from your loved ones) already has some experience.

Answer 2

If you are all new to KI technology, just pick one and get started.

• If you use GitLab and understand everything, as in the code, it makes sense to choose GitLab CI.
• If you need to have a dialogue with many other CI / CD tools or you need a graphical interface to create your work, choose Jenkins.

Those of you who use GitLab and are not sure that they will continue to do this, should still remember that choosing GitLab CI will mean destroying all your CI / CD pipelines.

And the last word: the balance is a little inclined towards Jenkins because of the many plugins, but there is a chance that GitLab CI will quickly fill this gap.

Answer 4

I would like to add some results from my recent experiment with GitLab CI. The features that came with 11.6 and 11.7 are just awesome!

In particular, I like only conditions that basically allow you to create separate pipelines for merge_request or push (full list here )

I also really like the lack of plugins. When I need more complex functionality, I just write my own Docker image that processes the required functionality (the same concept as in drone.io ).

If you are wondering about DRY , this is absolutely possible these days! You can write your own "templates"

 .myTemplate: image: node:10.14.2 script: - npm install - npm run test 

Put them in some public repository, include them in the main pipeline:

 include: - remote: https://.... 

And use them to extend the work:

 test: extends: .myTemplate only: refs: ["master"] variables: - $CI_PIPELINE_SOURCE == "push" 

I really love GitLab CI! Yes, he (for now) cannot draw good graphics with coverage and so on, but overall this is a really great tool!

Edit (2019-02-23): here is my post about the things that I love about GitLab CI. It was written in the 11.7 "era", so when you read this answer, GitLab CI probably has a lot more features.

Edit (2019-07-10): Gitlab CI now supports multiple extends , e.g.

 extends: - .pieceA - .pieceB 

Check out the white papers for more information on several extensions.

Answer 5

if your assembly / publishing / deployment and testing tasks are not too complicated, then using gitlab ci has natural advantages.

Since gitlab-ci.yml is present with your code in each branch, you can more efficiently change your ci / cd steps, especially tests (which vary in different environments).

For example, you want to do unit testing for any registration on the dev branch, while you may need to perform full-featured functional testing on the QA branches and a limited type of get tests in production, which can be easily achieved with gitlab ci.

The second advantage, in addition to the excellent user interface, is that it allows you to use docker images to perform any stage, while maintaining the operability of the host and, therefore, less error prone.

Moreover, gitlab ci will automatically register you, and you will not have to manage the jenkins wizard separately.