Jenkins

Have you ever wondered what Jenkins is all about when people around you always talk about it?

Well, I did too!! Not to be worried, now in my Blog on Jenkins I will try and make it easy to understand what Jenkins is and the concept of Continuous Integration.

Amazon makes changes to its production environment every 11.6 seconds. Facebook modifies its site at least a couple of times every day. In terms of software development, releases at this incredible cadence are made possible only thanks to tools and the infrastructure to commit, test, and deliver changes within a very short timeframe. This is where Jenkins has emerged as the most promising candidate. In this blog post let’s discuss continuous integration with Jenkins.

So Continuous Integration, It is defined by Martin Fowler as “Continuous Integration is a software development practice where members of a team integrate their work frequently, usually each person integrates at least daily – leading to multiple integrations per day. Each integration is verified by an automated build (including test) to detect integration errors as quickly as possible”

Continuous Integration – What does it really mean?

The Continuous Integration approach is designed to create an automation environment ensuring that every change to the application results in a releasable version, and that any version can be built automatically at the push of a button. At a broader level, Continuous Delivery aims to make the entire end to end release process of that application hands free (automated) where the built application (from Continuous Integration system), is delivered frequently to the testing and then production environments. The goal of the Continuous Delivery cycle is to ensure consistency and high quality by delivering fast user centric feedback [2]. Continuous Integration is an important subset of Continuous Delivery.

The goal of Continuous Integration is to automate traditionally manual stages in the application development process in which a feature complete version of the software is moving for the first time from development to the system integration and integration testing phase.

With Continuous Integration, applications are built from a very early stage in the development process at specific frequent intervals or on every change checked in by the developers. This effectively eliminates the need for integration testing and the cost associated with developers spending time on this phase. The enablement of frequent incremental builds and mandating a comprehensive automated testing process also allows developers to detect problems early and as a result, ensure higher application quality. [To summarize] :

  • At a regular frequency (ideally at every commit), the system is:
  1. Integrated

All changes up until that point are combined into the project

  1. Built

The code is compiled into an executable or package

  1. Tested

Automated test suites are run

  1. Archived

Versioned and stored so it can be distributed as is, if desired

  1. Deployed

Loaded onto a system where the developers can interact with it

CI – Workflow

Comaprision

CI – Benefits

  • Immediate bug detection
  • No integration step in the lifecycle
  • A deployable system at any given point
  • Record of evolution of the project

CI – The tools

  • Code Repositories
  1. SVN

  2. Mercurial

  3. Git

  • Continuous Build Systems
  1. Jenkins

  2. Bamboo

  3. Cruise Control

  • Test Frameworks
  1. JUnit
  2. Cucumber
  3. CppUnit
  • Artifact Repositories
  1. Nexus
  2. Artifactory
  3. Archiva

Jenkins – History

  • 2005 – Hudson was first release by Kohsuke Kawaguchi of Sun Microsystems
  • 2010 – Oracle bought Sun Microsystems
    • Due to a naming dispute, Hudson was renamed to Jenkins
    • Oracle continued development of Hudson (as a branch of the original)

What is Continuous Integration with Jenkins?

Jenkins is a Java-based cross-platform, continuous integration, and continuous delivery application that increases overall productivity. Jenkins can be used to build and test software projects continuously, making it easier for developers to integrate changes to the project, and making it easier for users to obtain a fresh build. It also allows you to continuously deliver your software by providing powerful ways to define your build pipelines and integrating with a large number of testing and deployment technologies.

Features of Jenkins

1. Jenkins can be configured entirely from its friendly web GUI with extensive on-the-fly error checks and inline help.

2. Jenkins integrates with virtually every (SCM) Supply chain management or build tool that exists today.

3. Most parts of Jenkins can be extended and modified, and it’s easy to create new Jenkins plugins. This feature allows you to customize Jenkins to your needs.

4. Jenkins can distribute build/test loads to multiple computers with different operating systems.

Why Jenkins? Flexibility!

  • Jenkins is a highly configurable system by itself
  • The additional community developed plugins provide even more flexibility
  • By combining Jenkins with Ant, Gradle, or other Build Automation tools, the possibilities are limitless

Jenkins – Fitting in

Jenkins_comp

Why Jenkins? Award winning!

  • InfoWorld Bossies Award, 2011

info

  • O’Reilly Open-Source Award, 2011

boss

  • ALM&SCM, SDTimes 100, 2010, 2011

sdtimes1sdtimes2

  • GlassFish Community Innovation Award 2008

glssf

  • Duke’s Choice Award 2008

duke

Jenkins Home page:
jenkins_h
What can Jenkins do?

To illustrate a typical Continuous Integration workflow, consider the following scenario:

1. During the development of the application, the developers are working on their local machines and once they are ready to submit their new code changes they commit them to the central source code repository. In the diagram below the Source Control Management (or version control) system is a Git repository.

2. When the code is checked in to the mainline (or the release manager merges code changes from one of the developers), the new code addition to the main branch triggers a new release.

3. The Continuous Integration system (Jenkins in this case) monitors the version control system for changes and launches the build process.

4. The Continuous Integration server gets the source code from the repository.

5. The Continuous Integration server runs unit tests to validate the quality.

6. The Continuous Integration server packages the files into distributable units and deploys the package onto a test server and validates the package and basic functionality by running automated functional tests.

7. The Continuous Integration server deploys the same package on the testing environments for thorough user acceptance testing.

8. Once the acceptance tests are successful the same package is deployed on the production servers. Implementing infrastructure and release automation enables end to end automation and allows provisioning and deploying the application packages on all servers with a click of a button.

workflow

 

This is about the overview of Jenkins.
References:

https://wiki.jenkins-ci.org/display/JENKINS/Awards

http://www.tutorialspoint.com/jenkins/

http://www.cloudhadoop.com/2013/05/jenkins-basics-continuous-integration.html#.VvOEl_l97IW

http://static.zend.com/topics/WP-Fundamentals-of-Continuous-Integration-with-Jenkins-and-Zend-Server-2014-03-31-EN.pdf

I Hope that I have covered the required concepts on Jenkins. Don’t forget to share your opinions/suggestions.

Jenkins-You-Can-Take-th-Evening-Off
Thank You for reading my Blog..!

 

 


Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s