GitLab CI, Jenkins, Azure Pipelines, CircleCI

The vocabulary you learned with GitHub Actions transfers to every other modern CI tool. Triggers, jobs, steps, runners, artefacts, environments — same shapes, different syntax. This lesson maps that vocabulary across the major platforms.

GitLab CI/CD

Built into GitLab. Pipelines are defined in .gitlab-ci.yml at the repo root.

stages: [test, build, deploy]

variables:
  IMAGE: $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA

test:
  stage: test
  image: node:20
  script:
    - npm ci
    - npm test
  cache:
    paths: [node_modules/]

build:
  stage: build
  image: docker:24
  services: [docker:24-dind]
  script:
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
    - docker build -t $IMAGE .
    - docker push $IMAGE

deploy_prod:
  stage: deploy
  environment:
    name: production
    url: https://app.example.com
  script:
    - kubectl set image deploy/app app=$IMAGE
  rules:
    - if: $CI_COMMIT_BRANCH == "main"
      when: manual

Strengths:

• Tightly integrated — issues, MRs, registry, packages, security all in one tool
• Excellent monorepo support — rules, parent-child pipelines, dynamic pipelines
• Can self-host the whole platform (GitLab CE)
• Auto DevOps — opinionated default pipeline that just works for many apps

Azure Pipelines

Microsoft's CI/CD, part of Azure DevOps. Two pipeline types: classic (UI) and YAML (preferred).

trigger:
  branches: { include: [main] }

pool:
  vmImage: ubuntu-latest

stages:
  - stage: Test
    jobs:
      - job: Test
        steps:
          - task: NodeTool@0
            inputs: { versionSpec: '20.x' }
          - script: npm ci && npm test

  - stage: Deploy
    dependsOn: Test
    jobs:
      - deployment: Prod
        environment: production
        strategy:
          runOnce:
            deploy:
              steps:
                - script: ./deploy.sh

Strengths:

• First-class Microsoft stack support (.NET, Windows agents, Azure)
• Self-hosted agents (Windows, Linux, Mac) — strong for enterprises and regulated industries
• Azure DevOps as a complete suite (Boards, Repos, Pipelines, Test Plans, Artifacts)
• YAML supports stages, deployment jobs, and environments natively

CircleCI

Hosted CI focused on speed and parallelism. Pipelines in .circleci/config.yml.

version: 2.1

orbs:
  node: circleci/node@5.2.0
  aws-s3: circleci/aws-s3@4.0.0

jobs:
  test:
    docker: [{ image: cimg/node:20.10 }]
    steps:
      - checkout
      - node/install-packages
      - run: npm test

  deploy:
    docker: [{ image: cimg/aws:2024.03 }]
    steps:
      - checkout
      - aws-s3/sync:
          from: ./dist
          to: s3://my-bucket

workflows:
  build-deploy:
    jobs:
      - test
      - deploy:
          requires: [test]
          filters: { branches: { only: main } }

Strengths:

• Orbs — extremely high-quality reusable packages
• Test splitting and parallelism that "just works"
• Fast — built for speed
• Strong macOS support for iOS builds

Jenkins

The grand-daddy of CI. Self-hosted, plugin-driven, infinitely flexible. Pipelines in a Jenkinsfile using Groovy DSL.

pipeline {
  agent any
  environment {
    IMAGE = "registry.example.com/app:${env.BUILD_NUMBER}"
  }
  stages {
    stage('Test') {
      steps {
        sh 'npm ci'
        sh 'npm test'
      }
    }
    stage('Build') {
      steps {
        sh 'docker build -t $IMAGE .'
        sh 'docker push $IMAGE'
      }
    }
    stage('Deploy Prod') {
      when { branch 'main' }
      input { message 'Deploy to production?' }
      steps {
        sh "kubectl set image deploy/app app=$IMAGE"
      }
    }
  }
  post {
    failure { slackSend channel: '#alerts', message: 'Build failed' }
  }
}

Strengths:

• Runs anywhere — on-prem, air-gapped, weird hardware
• 2,000+ plugins — almost any tool integration exists
• Mature, well-documented, vast community

Trade-offs:

• Operational burden — patching, plugin updates, disk maintenance
• Plugin ecosystem is uneven; supply-chain risks
• Groovy DSL is more powerful but steeper than YAML
• Many newer cloud-native projects have moved to GitHub Actions or GitLab CI

Others Worth Knowing

• Buildkite — bring-your-own-agents, dynamic pipelines, popular at scale
• Drone CI / Harness CI — container-native
• TeamCity — JetBrains, especially strong with .NET and JVM stacks
• Bamboo — Atlassian (legacy; being phased out)
• Argo Workflows / Tekton — Kubernetes-native pipeline engines, often combined with Argo CD for GitOps
• Spinnaker — Netflix-origin multi-cloud CD platform
• AWS CodePipeline / CodeBuild — first-party AWS, integrates tightly with their services
• Google Cloud Build — first-party GCP

How to Pick

Don't Reinvent the Pipeline

The same shape — checkout, build, test, package, deploy, validate — works for every team and every tool. Once you understand it conceptually, switching tools is mostly a YAML transcription exercise. Focus your energy on the substance of the pipeline (good tests, fast feedback, safe deploys), not the syntax of the platform.

Course Wrap-Up

You can now:

• Explain CI vs CD (delivery) vs CD (deployment)
• Build a multi-stage pipeline that lints, tests, builds, scans, and deploys
• Write GitHub Actions workflows including matrix builds and reusable workflows
• Authenticate to clouds with OIDC instead of static keys
• Implement blue/green, canary, and feature-flag deployments
• Run Terraform safely from a pipeline with plan/apply gates
• Measure pipeline health with DORA and add proper rollback
• Translate your knowledge to GitLab CI, Azure Pipelines, CircleCI, and Jenkins

The cert exams (DOP-C02, AZ-400, GitHub Actions) drill deeply on the same patterns. From here, hands-on practice is the fastest path — pick one tool, build a pipeline for a real project, and iterate.