Step by Step Tutorial on Creating Free Style Jobs in Jenkins

October 15, 2024

Jenkins, an open-source automation server, has revolutionized the landscape of continuous integration and continuous delivery (CI/CD) in software development. Among its myriad of features, freestyle jobs stand out as a versatile and powerful tool for automating various tasks in the software development lifecycle. This comprehensive tutorial will guide you through the process of creating and configuring freestyle jobs in Jenkins, empowering you to streamline your development workflows and enhance your team’s productivity.

Freestyle jobs in Jenkins offer unparalleled flexibility, allowing developers and DevOps engineers to automate a wide range of tasks, from simple script executions to complex build and deployment processes. By mastering the art of creating freestyle jobs, you’ll be able to customize your automation workflows to suit your project’s unique requirements, integrate with various tools and technologies, and ultimately accelerate your software delivery pipeline.

In this tutorial, we’ll delve into the step-by-step process of setting up freestyle jobs, explore best practices for configuration, and provide practical examples to illustrate key concepts. Whether you’re new to Jenkins or looking to expand your automation capabilities, this guide will equip you with the knowledge and skills to harness the full potential of freestyle jobs in your CI/CD pipeline.

Understanding Freestyle Jobs in Jenkins

What are Freestyle Jobs?

Freestyle jobs in Jenkins are a type of project that allows users to configure and automate various tasks with great flexibility. Unlike more specialized job types, freestyle jobs provide a blank canvas where you can define custom build steps, configure source code management, set up build triggers, and manage post-build actions. This versatility makes freestyle jobs suitable for a wide range of automation tasks, from simple script executions to complex multi-step build and deployment processes.

Key Features of Freestyle Jobs

Freestyle jobs offer a rich set of features that cater to diverse automation needs. Some of the key features include:

Source Code Management (SCM) integration: Freestyle jobs can be easily connected to various version control systems like Git, Subversion, or Mercurial.
Build Triggers: You can configure jobs to start automatically based on various conditions, such as code commits, scheduled times, or completion of other jobs.
Build Environment: Jenkins provides options to set up the build environment, including tool installations, environment variables, and workspace cleanup.
Build Steps: This is where you define the actual tasks to be executed, such as running shell commands, executing Windows batch files, or invoking build tools like Maven or Gradle.
Post-build Actions: After the build steps are completed, you can configure actions like archiving artifacts, publishing test results, sending notifications, or triggering other jobs.

When to Use Freestyle Jobs

Freestyle jobs are particularly useful in scenarios where you need custom automation that doesn’t fit neatly into more specialized job types. Some common use cases for freestyle jobs include:

Custom build processes that involve multiple technologies or tools
Integration testing across different components of a system
Deployment scripts that require specific sequences of operations
Data processing or ETL (Extract, Transform, Load) tasks
System maintenance and housekeeping operations

By understanding the nature and capabilities of freestyle jobs, you’ll be better equipped to leverage their power in your Jenkins automation strategy. In the following sections, we’ll walk through the process of creating and configuring a freestyle job, step by step.

Prerequisites for Creating Freestyle Jobs

Before diving into the creation of freestyle jobs, it’s essential to ensure that you have the necessary prerequisites in place. This preparation will help you smoothly navigate through the tutorial and successfully implement freestyle jobs in your Jenkins environment.

Jenkins Installation and Access

First and foremost, you need to have Jenkins installed and running on your system or server. If you haven’t already set up Jenkins, you can follow these general steps:

Ensure you have Java installed on your system (Jenkins requires Java 8 or later).
Download the Jenkins WAR file from the official Jenkins website.
Run Jenkins using the command: java -jar jenkins.war
Access the Jenkins web interface through your browser, typically at http://localhost:8080

Once you have Jenkins up and running, make sure you have administrative access to create and configure jobs.

Required Plugins

While freestyle jobs can be created with a basic Jenkins installation, certain plugins can enhance their functionality. Here are some recommended plugins:

Git Plugin: For integrating with Git repositories
Credentials Plugin: For securely managing authentication credentials
Workspace Cleanup Plugin: For managing job workspace
Email Extension Plugin: For advanced email notifications

To install these plugins:

Navigate to “Manage Jenkins” > “Manage Plugins”
Go to the “Available” tab
Search for the required plugins
Select the plugins and click “Install without restart”

System Configuration

Ensure that your Jenkins system is properly configured:

Set up necessary tool locations (e.g., JDK, Maven, Gradle) in “Manage Jenkins” > “Global Tool Configuration”
Configure system settings like email notifications in “Manage Jenkins” > “Configure System”

Source Code Repository

If your freestyle job will interact with source code, make sure you have:

A version control system (e.g., Git) installed and configured
Access to the repository where your source code is hosted

Build Tools and Dependencies

Depending on your project requirements, you may need:

Build tools like Maven, Gradle, or Ant installed and configured in Jenkins
Any specific dependencies or libraries required by your project

Workspace Considerations

Consider the following regarding your Jenkins workspace:

Ensure sufficient disk space for job workspaces
Plan for workspace cleanup strategies to manage disk usage

By ensuring these prerequisites are met, you’ll be well-prepared to create and configure freestyle jobs effectively. In the next section, we’ll start the process of creating a new freestyle job in Jenkins.

Creating a New Freestyle Job

Now that we have our prerequisites in order, let’s walk through the process of creating a new freestyle job in Jenkins. This section will cover the initial setup and basic configuration of your job.

Step 1: Accessing the Jenkins Dashboard

Open your web browser and navigate to your Jenkins instance (e.g., http://localhost:8080).
Log in with your Jenkins credentials if prompted.

Step 2: Initiating Job Creation

On the Jenkins dashboard, click on “New Item” in the left sidebar.
In the “Enter an item name” field, type a name for your new job. Choose a descriptive name that reflects the purpose of the job.
Scroll down and select “Freestyle project” from the list of project types.
Click “OK” to proceed to the job configuration page.

Step 3: Configuring General Settings

On the job configuration page, you’ll see several sections. Let’s start with the General settings:

Description: Provide a brief description of what this job does. This helps team members understand the job’s purpose.
Discard old builds: Check this option to manage disk usage.
- Set “Max # of builds to keep” (e.g., 10)
- Set “Days to keep builds” (e.g., 30)
GitHub project: If your project is hosted on GitHub, check this option and enter the project URL.
This project is parameterized: Check this if you want to pass parameters to your job. We’ll cover this in more detail later.
Disable this project: Leave this unchecked unless you want to temporarily prevent the job from running.
Restrict where this project can be run: Use this if you have multiple build agents and want to restrict this job to specific ones.

Step 4: Configuring Source Code Management

In this section, you’ll connect your job to your source code repository:

Select the appropriate SCM system (e.g., Git, Subversion).
For Git:

Enter the Repository URL
Add credentials if required (click “Add” > “Jenkins”)
Specify the branch to build (e.g., */main for the main branch)

Step 5: Configuring Build Triggers

This section determines when your job will run:

Trigger builds remotely: Allows you to trigger builds via a URL.
Build after other projects are built: Run this job after specific other jobs complete.
Build periodically: Set up a cron-like schedule for regular builds.
GitHub hook trigger for GITScm polling: Use this if you want to trigger builds on GitHub pushes.
Poll SCM: Regularly check the repository for changes and build if changes are detected.

For now, you can leave these options unconfigured or choose based on your specific needs.

Step 6: Configuring Build Environment

This section allows you to set up the environment for your build:

Delete workspace before build starts: Ensures a clean workspace for each build.
Use secret text(s) or file(s): For securely passing credentials to the build.
Add timestamps to the Console Output: Helpful for debugging and log analysis.

Step 7: Saving the Job

After configuring these initial settings:

Scroll to the bottom of the page.
Click “Save” to create your new freestyle job.

Congratulations! You’ve now created a basic freestyle job in Jenkins. In the following sections, we’ll dive deeper into configuring build steps, post-build actions, and advanced features to make your job truly powerful and tailored to your needs.

Configuring Build Steps

Build steps are the heart of your freestyle job, defining the actual work to be performed. In this section, we’ll explore how to add and configure various types of build steps to create a comprehensive automation workflow.

Understanding Build Steps

Build steps in Jenkins are executed sequentially, allowing you to create a series of actions that make up your job. These can range from simple shell commands to complex build tool invocations.

Adding Build Steps

To add build steps to your freestyle job:

Navigate to your job’s configuration page.
Scroll down to the “Build” section.
Click on “Add build step” to see a dropdown of available step types.

Types of Build Steps

Jenkins offers several types of build steps. Here are some commonly used ones:

Execute shell: For running shell commands (Unix/Linux)
Execute Windows batch command: For running batch commands (Windows)
Invoke top-level Maven targets: For Maven projects
Invoke Gradle script: For Gradle projects
Run with timeout: Allows you to set a timeout for a group of build steps

Let’s look at how to configure some of these step types:

Example 1: Execute Shell

This is useful for running shell commands or scripts:

Add build step > Execute shell

# In the Command field, enter your shell commands:
echo "Starting build process..."
mvn clean install
./run_tests.sh

Example 2: Invoke Maven Targets

For Maven projects:

Add build step > Invoke top-level Maven targets

# Configure as follows:
Maven Version: (Select your configured Maven version)
Goals: clean install
POM: pom.xml

Example 3: Conditional Build Step

To add conditional logic to your build:

Install the “Conditional BuildStep” plugin if not already installed.
Add build step > Conditional step (single)
Configure the condition (e.g., based on a build parameter)
Add the build steps to be executed if the condition is met

Organizing Multiple Build Steps

For complex jobs with multiple build steps:

Use “Add build step” to create a sequence of steps.
Use the up and down arrows next to each step to reorder them.
Consider grouping related steps using the “Execute shell” step for better organization.

Best Practices for Build Steps

Keep it modular: Break down complex processes into smaller, manageable steps.
Use variables: Leverage environment variables and job parameters for flexibility.
Error handling: Include error checking in your scripts to catch and report issues.
Logging: Add echo statements or logging to provide visibility into the build process.

Example: Comprehensive Build Process

Here’s an example of a more complex build process using multiple steps:

Step 1: Execute shell
echo "Starting build for version ${VERSION}"
mvn clean install -DskipTests

Step 2: Execute shell
echo "Running unit tests..."
mvn test

Step 3: Conditional step (single)
Condition: String match
    Name: DEPLOY_ENV
    Value: production
Build Steps:
    Execute shell:
        echo "Deploying to production..."
        ./deploy_to_prod.sh

Step 4: Execute shell
echo "Build process completed."

In this example, we start with a clean install, run tests, conditionally deploy to production based on a parameter, and finish with a completion message.

By effectively configuring build steps, you can create powerful and flexible automation workflows in your Jenkins freestyle jobs. In the next section, we’ll explore how to enhance your job further with post-build actions.

Configuring Post-Build Actions

Post-build actions in Jenkins freestyle jobs allow you to perform various tasks after the build steps have been executed. These actions can include archiving artifacts, publishing test results, sending notifications, and triggering other jobs. Properly configured post-build actions can significantly enhance the value and functionality of your Jenkins jobs.

Adding Post-Build Actions

To add post-build actions to your freestyle job:

Navigate to your job’s configuration page.
Scroll down to the “Post-build Actions” section at the bottom.
Click on “Add post-build action” to see a dropdown of available actions.

Common Post-Build Actions

Let’s explore some of the most commonly used post-build actions and how to configure them:

1. Archive the artifacts

This action allows you to save build outputs for later use or download.

Configuration:

Add post-build action > Archive the artifacts

Files to archive: target/*.jar, reports/**/*
Exclude: **/*.tmp

2. Publish JUnit test result report

If your build runs JUnit tests, this action publishes the results in Jenkins.

Configuration:

Add post-build action > Publish JUnit test result report

Test report XMLs: **/target/surefire-reports/*.xml

3. Email Notification

Send email notifications about the build status.

Configuration:

Add post-build action > E-mail Notification

Recipients: team@example.com

For more advanced email notifications, use the “Editable Email Notification” action provided by the Email Extension Plugin.

4. Trigger parameterized build on other projects

This action allows you to start other Jenkins jobs based on the outcome of the current job.

Configuration:

Add post-build action > Trigger parameterized build on other projects

Projects to build: DeployJob
Trigger when build is: Stable
Add Parameters > Predefined parameters:
    VERSION=${BUILD_NUMBER}
    ENVIRONMENT=staging

5. Build other projects

Similar to the previous action, but without parameter passing.

Configuration:

Add post-build action > Build other projects

Projects to build: CleanupJob, NotifyJob
Trigger only if build is stable

Advanced Post-Build Configurations

For more complex scenarios, consider these advanced configurations:

Conditional Post-Build Actions

Use the Conditional BuildStep plugin to add conditions to your post-build actions:

Install the “Conditional BuildStep” plugin.
Add post-build action > Conditional steps (single or multiple)
Define your condition (e.g., based on build status or parameters)
Add the post-build actions to be executed if the condition is met

Groovy Postbuild Plugin

For ultimate flexibility, use the Groovy Postbuild plugin to write custom post-build logic:

Install the “Groovy Postbuild” plugin.
Add post-build action > Groovy Postbuild
Write your Groovy script to perform custom actions

Example Groovy script:

if (manager.logContains(".*Error.*")) {
    manager.buildUnstable()
    manager.createSummary("warning.gif").appendText("<h1>Build contains errors</h1>", false, false, false, "red")
    manager.addShortText("Errors found", "red", "white", "0px", "white")
}

Best Practices for Post-Build Actions

Cleanup: Use post-build actions to clean up temporary files or resources.
Notifications: Keep relevant team members informed about build statuses.
Artifact Management: Archive important build outputs for future reference.
Chaining Jobs: Use post-build actions to create complex workflows by triggering other jobs.
Failure Analysis: Implement actions that help quickly identify and communicate build failures.

Example: Comprehensive Post-Build Configuration

Here’s an example of a more comprehensive post-build configuration that combines several actions:

Post-build Action 1: Archive the artifacts
Files to archive: target/*.jar, reports/**/*

Post-build Action 2: Publish JUnit test result report
Test report XMLs: **/target/surefire-reports/*.xml

Post-build Action 3: Editable Email Notification
Project From: jenkins@example.com
Project Recipient List: team@example.com, manager@example.com
Project Reply-To List: no-reply@example.com
Content Type: HTML
Default Subject: $PROJECT_NAME - Build # $BUILD_NUMBER - $BUILD_STATUS!
Default Content: 
<html>
<body>
<h2>$PROJECT_NAME - Build # $BUILD_NUMBER - $BUILD_STATUS</h2>
<p>Check console output at <a href="$BUILD_URL">$BUILD_URL</a> to view the results.</p>
</body>
</html>

Triggers:
    Success:
        Send To: Recipient List
    Failure:
        Send To: Recipient List
        Add developers

Post-build Action 4: Trigger parameterized build on other projects
Projects to build: DeployJob
Trigger when build is: Stable
Add Parameters > Predefined parameters:
    VERSION=${BUILD_NUMBER}
    ENVIRONMENT=staging

This configuration archives build artifacts, publishes test results, sends detailed email notifications, and triggers a deployment job if the build is successful.

By effectively utilizing post-build actions, you can create a robust and informative build process that not only performs the necessary tasks but also communicates results and initiates further actions as needed.

Advanced Jenkins Freestyle Job Techniques

As you become more comfortable with creating and configuring freestyle jobs in Jenkins, you can leverage advanced techniques to create more powerful and efficient automation workflows. This section will explore some of these advanced concepts and how to implement them in your freestyle jobs.

Parameterized Builds

Parameterized builds allow you to pass variables to your job at runtime, making your jobs more flexible and reusable.

To set up a parameterized build:

In your job configuration, check “This project is parameterized”
Click “Add Parameter” and choose the type of parameter (e.g., String Parameter, Choice Parameter)
Configure the parameter details (name, default value, description)

Example:

Add Parameter > Choice Parameter
Name: ENVIRONMENT
Choices:
development
staging
production
Description: Select the deployment environment

You can then use this parameter in your build steps or post-build actions using the syntax ${ENVIRONMENT}.

Using Environment Variables

Jenkins provides many built-in environment variables, and you can also define your own. These can be used in your build steps and post-build actions.

Some useful built-in variables:

${BUILD_NUMBER}: The current build number
${JOB_NAME}: The name of the job
${WORKSPACE}: The path to the job’s workspace

To define a custom environment variable:

Go to “Manage Jenkins” > “Configure System”
Scroll to “Global properties”
Check “Environment variables”
Click “Add” and enter the name and value

Workspace Management

Proper workspace management is crucial for maintaining clean and efficient builds:

Use the “Delete workspace before build starts” option in the job configuration to ensure a clean slate for each build.
Implement a cleanup routine in your post-build actions to remove unnecessary files.
Use the “Discard old builds” option to manage disk usage.

Implementing Build Timeouts

To prevent jobs from running indefinitely due to errors:

Install the “Build Timeout” plugin
In your job configuration, add a “Build Environment” step: “Abort the build if it’s stuck”
Configure the timeout period and actions to be taken on timeout

Parallel Execution

For complex jobs with independent steps, you can use parallel execution to speed up your build:

Install the “Parallel Test Executor Plugin”
In your build steps, add a “Parallel Test Executor Step”
Configure the parallel processes as needed

Integrating with External Tools

Freestyle jobs can integrate with a wide variety of external tools. Here are a few examples:

SonarQube for Code Quality Analysis:

Install the SonarQube Scanner plugin
Add a build step: “Execute SonarQube Scanner”
Configure the SonarQube server and project properties

Artifactory for Artifact Management:

Install the Artifactory plugin
Configure Artifactory server in Jenkins system configuration
Use Artifactory-specific build steps to interact with your Artifactory repository

Slack for Notifications:

Install the Slack Notification plugin
Configure your Slack workspace in Jenkins system configuration
Add a post-build action: “Slack Notifications”

Creating Job Templates

To standardize your jobs and save time:

Create a job with the configuration you want to reuse
Use the “Copy Job” feature to create new jobs based on this template
Alternatively, use the “Job DSL” or “Pipeline Template” plugins for more advanced templating

Implementing Approval Steps

For jobs that require manual approval:

Install the “Pipeline: Stage Step” plugin
In your build steps, add an “Approval” step using a Groovy script:

input message: 'Proceed with deployment?', ok: 'Deploy'

This will pause the job and wait for user input before proceeding.

Version Control for Job Configurations

To maintain version control of your job configurations:

Install the “Job Configuration History Plugin”
This will automatically track changes to job configurations
You can view and restore previous configurations as needed

Monitoring and Analytics

To gain insights into your build processes:

Install plugins like “Global Build Stats Plugin” or “Dashboard View”
These provide visualizations and analytics of your build data
Use this information to optimize your build processes and resource allocation

By implementing these advanced techniques, you can create highly sophisticated and efficient freestyle jobs in Jenkins. These methods allow for greater flexibility, better resource management, and more insightful build processes, ultimately leading to a more robust and productive CI/CD pipeline.

Best Practices and Common Pitfalls

As you become more proficient in creating and managing freestyle jobs in Jenkins, it’s important to adhere to best practices and be aware of common pitfalls. This section will guide you through some key considerations to ensure your Jenkins freestyle jobs are efficient, maintainable, and reliable.

Best Practices

Keep Jobs Focused: Each job should have a single, well-defined purpose. This makes jobs easier to manage and troubleshoot.
Use Descriptive Names: Choose clear, descriptive names for your jobs and build parameters. This improves understandability and maintainability.
Implement Version Control: Store job configurations and build scripts in version control. This provides traceability and makes it easier to roll back changes if needed.
Utilize Parameterization: Make your jobs flexible by using parameters. This reduces the need for multiple similar jobs.
Implement Proper Error Handling: Ensure your build steps and scripts have proper error handling and logging. This makes troubleshooting easier.
Regular Cleanup: Implement workspace cleanup and artifact management strategies to prevent disk space issues.
Security Best Practices: Use Jenkins’ built-in security features. Avoid hardcoding sensitive information; use credentials management instead.
Documentation: Maintain clear documentation for your jobs, including their purpose, parameters, and any special considerations.
Consistent Build Environments: Use tools like Docker to ensure consistent build environments across different machines.
Regular Maintenance: Regularly review and optimize your jobs. Remove obsolete jobs and consolidate similar ones.

Common Pitfalls

Overly Complex Jobs: Avoid creating jobs that try to do too much. If a job becomes too complex, consider breaking it into multiple jobs.
Ignoring Performance: Be mindful of resource usage. Jobs that consume excessive resources can slow down your entire Jenkins instance.
Neglecting Notifications: Ensure that the right people are notified of build results, especially failures.
Inconsistent Naming Conventions: Lack of standardized naming can lead to confusion and difficulty in managing jobs.
Hardcoding Configuration: Avoid hardcoding environment-specific configuration. Use parameters or environment variables instead.
Insufficient Logging: Poor logging practices can make it difficult to troubleshoot issues when they occur.
Ignoring Scalability: As your number of jobs grows, consider how your Jenkins setup will scale. Plan for growth from the beginning.
Neglecting Security: Failing to properly secure Jenkins can lead to serious security vulnerabilities.
Not Using Plugins Effectively: While plugins can greatly enhance Jenkins’ capabilities, using too many or poorly maintained plugins can lead to stability issues.
Ignoring Backup and Disaster Recovery: Ensure you have a solid backup and recovery plan for your Jenkins configuration and data.

Table: Job Creation Checklist

Here’s a handy checklist to review when creating new freestyle jobs:

Aspect	Considerations
Purpose	Is the job’s purpose clear and focused?
Naming	Is the job name descriptive and consistent with naming conventions?
Source Control	Is the source code repository correctly configured?
Build Steps	Are the build steps clearly defined and in the correct order?
Parameters	Have you used parameters to make the job flexible?
Error Handling	Is there proper error handling and logging in place?
Workspace	Is workspace management (cleanup, etc.) configured?
Artifacts	Are important artifacts being archived?
Notifications	Are the right notifications configured?
Security	Are credentials and sensitive data being handled securely?
Documentation	Is there clear documentation for the job?
Performance	Have you considered the resource usage of the job?
Post-build Actions	Are necessary post-build actions configured?
Integration	Does the job integrate properly with other systems/jobs if required?

By following these best practices and avoiding common pitfalls, you can create robust, efficient, and maintainable freestyle jobs in Jenkins. Remember, the key to successful Jenkins usage is regular review and optimization of your jobs and overall setup.

Conclusion

Creating freestyle jobs in Jenkins is a powerful way to automate and streamline your software development processes. Throughout this tutorial, we’ve explored the various aspects of setting up and configuring freestyle jobs, from basic creation to advanced techniques and best practices.

We began by understanding the nature of freestyle jobs and their place in the Jenkins ecosystem. We then walked through the step-by-step process of creating a new job, configuring its general settings, and setting up source code management. We delved into the crucial aspects of configuring build steps and post-build actions, which form the core of any Jenkins job’s functionality.

As we progressed, we explored more advanced techniques, such as parameterized builds, environment variables, workspace management, and integration with external tools. These advanced features allow you to create more sophisticated and flexible automation workflows tailored to your specific needs.

Finally, we discussed best practices and common pitfalls to be aware of when working with freestyle jobs. By adhering to these guidelines, you can ensure that your Jenkins setup remains efficient, maintainable, and secure as it grows and evolves.

Remember, mastering Jenkins freestyle jobs is an ongoing process. As you continue to work with Jenkins, you’ll discover new ways to optimize your workflows and leverage its capabilities. Don’t hesitate to explore the vast ecosystem of Jenkins plugins and the active community for further enhancements and solutions to specific challenges you may encounter.

By effectively utilizing freestyle jobs in Jenkins, you’re taking a significant step towards improving your team’s productivity, enhancing the quality of your software, and streamlining your development and deployment processes. Continuous integration and continuous delivery become more achievable and manageable, allowing your team to focus more on creating value and less on repetitive, manual tasks.

As you apply the knowledge gained from this tutorial, keep experimenting, learning, and adapting your Jenkins setup to meet your evolving needs. With practice and exploration, you’ll be well on your way to becoming a Jenkins expert, capable of creating powerful, efficient, and reliable automation workflows for your projects.

Disclaimer: This tutorial is based on general best practices and common usage patterns for Jenkins freestyle jobs. Specific versions of Jenkins or plugins may have slight variations in functionality or user interface. Always refer to the official Jenkins documentation for the most up-to-date and version-specific information. If you notice any inaccuracies or have suggestions for improvement, please report them so we can update the content promptly.