JobGenie - Your DevOps Superpower Unleashed

Why JobGenie?

Revolutionizing DevOps with GitOps-native Jenkins automation

Zero Manual Config

Define jobs in YAML, auto-generated in Jenkins

Auto-Discovery

Automatically detects YAML job definitions

GitOps Native

Full version control and audit trail

Team Collaboration

Multiple developers work simultaneously

Problems Before JobGenie

Manual job creation overhead and prone to errors
Configuration drift across environments
Scalability challenges for new services
Lack of audit trail and history
Environment inconsistencies

Solutions With JobGenie

YAML definitions, auto-generated in Jenkins
All configurations in Git, always consistent
Add YAML entry, jobs created automatically
Full Git history with pull requests and reviews
Single source of truth with overrides

Multi-Stage Seed Jobs

Hierarchical seed job architecture for isolated job management without affecting other jobs

Hierarchical Structure

1

Root Level

0-JobGenie-Generator

Master seed job that manages all organization-level generators

2

Organization Level

0-<Organization-name>-JobGenerator

Manages all projects within an organization

3

Project/Vertical Level

0-<Org>-<Project>-JobGenerator

Manages jobs for specific projects or verticals

4

Environment Level

0-<Org>-<Project>-<Env>-JobGenerator

Manages jobs for specific environments (dev, staging, prod)

Key Benefits

Isolated Job Management

Each level manages its own jobs independently without affecting others

Granular Access Control

Different teams can manage their own seed jobs with appropriate permissions

Selective Synchronization

Sync or create jobs at specific levels without touching other jobs

Scalable Architecture

Supports multiple organizations, projects, and environments seamlessly

Version Control Integration

Each level can have its own Git repository and branch strategy

Supercharge Jenkins Administration

Automate Jenkins setup, configuration, and administration with Ansible for infrastructure as code

Automated Configuration Management

User Access Management

Automate user creation, role assignment, and permission management

Permission Configuration

Define and enforce access control policies as code

System Configuration

Manage Jenkins system settings, global tools, and environment variables

Plugin Management

Install, update, and configure Jenkins plugins automatically

Node Management

Configure and manage Jenkins agents, build nodes, and cloud instances

Global Tools Configuration

Automate JDK, Maven, Docker, and other tool installations

Key Advantages

Infrastructure as Code

All Jenkins configurations version-controlled in Git

Idempotent Operations

Safe to run multiple times - only changes what's needed

Consistent Environments

Ensure all Jenkins instances have identical configurations

Rapid Provisioning

Spin up new Jenkins instances in minutes, not hours

Easy Rollback

Revert configuration changes via Git and re-run playbooks

Team Collaboration

Multiple admins can review and approve configuration changes

Key Benefits

Experience the power of automated CI/CD with JobGenie's comprehensive feature set

Faster Onboarding - New services onboarded in minutes, not days

Reduced Errors - YAML validation catches errors before deployment

Better Visibility - All job configurations visible in Git

Easy Rollback - Revert job changes via Git revert

Scalability - Handle hundreds of jobs with minimal effort

Security & Compliance - All configurations version-controlled

YAML-Driven Configuration

Simple YAML, Powerful Pipelines

Define complex Jenkins jobs with simple, readable YAML syntax

simple-job.yml

Simple Job Definition: Create a basic Jenkins job with minimal configuration. Perfect for getting started.

jobgenie:
  default:
    HOME_DIR: prod
    GROUP: "v4"
    ENV: "prod"
  jobs:
    - NAME: "my-service"
      PARAMETERS:
        - { name: 'GitBranch', string: 'main', description: 'Git branch to build.' }
      CONFIGS:
        APP_REPO: "my-service-repo"
        APP_BRANCH: "main"

multi-parameter.yml

Multiple Parameters: Define jobs with multiple build parameters including strings, booleans, and choices.

jobgenie:
  default:
    HOME_DIR: prod
    GROUP: "v2"
    ENV: "prod"
  jobs:
    - NAME: "microservices-orchestrator"
      PARAMETERS:
        - { name: 'TAG', string: 'v3.2.1', description: 'Application version tag.' }
        - { name: 'Services', string: 'all', description: 'Services to deploy.' }
        - { name: 'RollbackOnFailure', bool: true, description: 'Auto-rollback on failure.' }
      CONFIGS:
        SERVICE: "microservices-orchestrator"
        APP_REPO: "microservices-platform"
        APP_BRANCH: "production"

terraform-job.yml

Infrastructure as Code: Deploy Terraform infrastructure with custom scripts and parameter choices.

jobs:
  - NAME: "terraform-infrastructure-deploy"
    PARAMETERS:
      - { name: 'GitBranch', string: 'main', description: 'Terraform code branch.' }
      - { name: 'TerraformAction', choice: ['plan', 'apply', 'destroy'], description: 'Terraform action.' }
      - { name: 'Region', string: 'us-east-1', description: 'AWS region.' }
    CONFIGS:
      JOB_TYPE: "freestyle"
      APP_REPO: "terraform-infrastructure"
      APP_BRANCH: "main"
      SCRIPT: |
        echo "Executing Terraform ${TerraformAction} in ${Region}"
        terraform init
        terraform ${TerraformAction}

security-scan.yml

Security Scanning: Configure security vulnerability scans with multiple scan types and severity levels.

jobs:
  - NAME: "security-vulnerability-scan"
    PARAMETERS:
      - { name: 'ScanType', choice: ['container', 'code', 'dependency'], description: 'Scan type.' }
      - { name: 'Severity', choice: ['critical', 'high', 'medium', 'all'], description: 'Severity level.' }
    CONFIGS:
      JOB_TYPE: "freestyle"
      APP_REPO: "security-scanner"
      APP_BRANCH: "main"
      SCRIPT: |
        echo "Running ${ScanType} security scan with ${Severity} severity"

custom-dsl-job.yml

Custom DSL Scripts: Execute custom Groovy DSL scripts for advanced Jenkins configuration management.

jobs:
  - NAME: "jenkins-config-sync"
    PARAMETERS:
      - { name: 'ConfigBranch', string: 'master', description: 'Config branch.' }
    CONFIGS:
      JOB_TYPE: "freestyle"
      SKIP_GIT: true
      SKIP_ENJECTED_VARS: true
      DSL_SCRIPT: |
        import io.jenkins.plugins.casc.ConfigurationAsCode;
        ConfigurationAsCode.get().configure()
        println("Configuration sync completed")

blue-green-deployment.yml

Zero-Downtime Deployment: Configure blue-green deployments with traffic percentage control.

jobs:
  - NAME: "blue-green-deployment"
    PARAMETERS:
      - { name: 'ApplicationName', string: '', description: 'Application name.' }
      - { name: 'TrafficPercentage', string: '10', description: 'Traffic percentage.' }
    CONFIGS:
      SERVICE: "blue-green-deployment"
      CICD_TEMPLATE_NAME: "blue-green-deploy-template"
      APP_REPO: "deployment-automation"
      APP_BRANCH: "main"

database-backup.yml

Database Operations: Automate database backups with support for multiple database types and backup strategies.

jobs:
  - NAME: "database-backup-job"
    PARAMETERS:
      - { name: 'DatabaseType', choice: ['postgresql', 'mysql', 'mongodb'], description: 'Database type.' }
      - { name: 'BackupType', choice: ['full', 'incremental'], description: 'Backup type.' }
    CONFIGS:
      JOB_TYPE: "freestyle"
      APP_REPO: "backup-scripts"
      APP_BRANCH: "master"

custom-path-job.yml

Custom Path Organization: Organize jobs in custom folder structures using the PIPELINE_PATH configuration.

jobs:
  - NAME: "shared/notification-service"
    PARAMETERS:
      - { name: 'GitBranch', string: 'main', description: 'Application branch.' }
    CONFIGS:
      APP_REPO: "notification-service"
      APP_BRANCH: "main"
      PIPELINE_PATH: "shared"

Declarative Syntax

Simple, readable YAML syntax for complex pipelines

Multi-Environment

Support for multiple environments from single definitions

Template Support

Reusable pipeline templates for consistent deployments

Architecture

Streamlined architecture for reliable job generation

Seed Job Execution

Runs manually or via webhook

YAML Discovery

Scans repository for *-jobs.yml files

YAML Parsing

Parses using SnakeYAML library

Job Generation

Uses JobDSL to create/update jobs

Component Flow

YAML files in Git repository

Automatic scanning and parsing

JobDSL generates Jenkins jobs

Ready-to-use pipeline jobs

Get Started in Minutes

Transform your CI/CD workflow in three simple steps

1

Create YAML Definition

Create your first YAML job definition following the naming convention

amazon/myproject/prod/jobs/myproject-prod-jobs.yml

2

Commit & Push

Add your YAML file to Git and push to your repository

git add .
git commit -m "Add job definition"
git push origin main

3

Run Seed Job

Trigger JobGenie to generate jobs

Build → Verify

Download Complete Guide

Open Source • Free Forever

Supercharge Your Jenkins

Join the community transforming CI/CD workflows with YAML-driven automation

Star on GitHub Get Started