End-to-End Enterprise DevOps Pipeline: Building Automations with Git, Jenkins, Ansible & Docker

The Evolution of Modern Software Delivery

Continuous Integration and Continuous Deployment (CI/CD) pipelines serve as the operational engine behind modern high-velocity software platforms. Automated delivery pipelines enable enterprise development teams to commit code changes, perform automated testing, enforce static code security analysis, package container images, and deploy software releases seamlessly to production environments with minimal human intervention.

1. Architecture of an Enterprise CI/CD Pipeline

A resilient CI/CD pipeline consists of interconnected toolchains that automate key application lifecycle phases:

1. Source Code Management (SCM): Git, GitHub, or GitLab repository workflows.
2. Build & Unit Test Automation: Jenkins, GitLab CI, or GitHub Actions compiling artifacts.
3. Code Quality & SAST Analysis: Static code inspection via SonarQube.
4. Artifact Management: Docker Registry, Nexus, or JFrog Artifactory image tagging.
5. Configuration Management & Deployment: Infrastructure automation using Ansible and Kubernetes.

2. Declarative Jenkins Pipeline Integration

Jenkins pipelines defined via code (using a Jenkinsfile) ensure continuous delivery pipelines remain version-controlled, reproducible, and easily auditable across engineering teams.

Production Declarative Jenkinsfile Example:

pipeline {
    agent any
    
    environment {
        REGISTRY = "registry.oselabs.com"
        IMAGE_NAME = "enterprise-app"
        IMAGE_TAG = "${BUILD_NUMBER}"
    }

    stages {
        stage('Checkout') {
            steps {
                git branch: 'main', url: 'https://github.com/oselabs/enterprise-app.git'
            }
        }
        
        stage('Static Code Analysis') {
            steps {
                script {
                    echo "Executing SonarQube Code Scanning..."
                    // sh 'mvn sonar:sonar'
                }
            }
        }
        
        stage('Build Docker Image') {
            steps {
                sh "docker build -t ${REGISTRY}/${IMAGE_NAME}:${IMAGE_TAG} ."
            }
        }
        
        stage('Security Vulnerability Scan') {
            steps {
                sh "trivy image ${REGISTRY}/${IMAGE_NAME}:${IMAGE_TAG}"
            }
        }
        
        stage('Push Image to Private Registry') {
            steps {
                script {
                    sh "docker push ${REGISTRY}/${IMAGE_NAME}:${IMAGE_TAG}"
                }
            }
        }
        
        stage('Automated Ansible Deployment') {
            steps {
                sh "ansible-playbook -i deploy/hosts deploy/playbook.yml --extra-vars 'image_tag=${IMAGE_TAG}'"
            }
        }
    }

    post {
        always {
            cleanWs()
        }
        success {
            echo "CI/CD Pipeline Completed Successfully!"
        }
        failure {
            echo "Pipeline Failed. Triggering Team Notification..."
        }
    }
}

3. Configuration Management with Ansible (RHCE Track)

While Jenkins handles application orchestration, Ansible manages automated server provisioning, OS patching, package configuration, and cluster provisioning without needing agent software installed on remote target hosts.

Production Deployment Playbook Example:

---
- name: Deploy Production Application Container
  hosts: webservers
  become: yes
  vars:
    app_image: "registry.oselabs.com/enterprise-app"
    app_version: "{{ image_tag }}"

  tasks:
    - name: Ensure target directory exists
      file:
        path: /opt/app
        state: directory
        mode: '0755'

    - name: Pull updated container image
      containers.podman.podman_image:
        name: "{{ app_image }}:{{ app_version }}"
        state: present

    - name: Re-create application service container
      containers.podman.podman_container:
        name: enterprise_web
        image: "{{ app_image }}:{{ app_version }}"
        state: started
        recreate: yes
        ports:
          - "80:8080"

4. Enforcing Security Policies (DevSecOps)

Shifting security left requires security guardrails to be integrated directly into early stages of development pipelines rather than applied post-release. Key implementation tasks include:

• Enforcing dependency vulnerability vulnerability checks during build phases.
• Scanning container base layers for known CVE issues before pushing artifacts.
• Encrypting production secrets, API credentials, and private keys using Ansible Vault or HashiCorp Vault.

5. Industry Career Demand for DevOps Engineers

Enterprise organizations actively hire DevOps and Platform Engineers who demonstrate proven mastery of Linux administration, container deployment, infrastructure automation, and automated deployment pipelines.

Core Technical Competencies Required by Enterprise Recruiters:

• Strong Linux System Administration foundation (RHEL/CentOS/Debian).
• Hands-on container management experience (Docker, Podman, Kubernetes, OpenShift).
• Infrastructure as Code (IaC) experience (Ansible, Terraform).
• Production experience creating, maintaining, and debugging Jenkins pipelines and Git repositories.

Summary & Learning Path

Building automated infrastructure platforms requires practical execution experience. The DevOps Masterclass and RHCE Automation training programs at OSELabs guide students through real-world deployment scenarios, providing production-grade CI/CD pipeline experience to help candidates stand out during enterprise hiring reviews.