The Other Forges

GitLab CI, Bitbucket Pipelines, Jenkins and portability

Why learn multiple platforms?

You might wonder: "If I know GitHub Actions, why learn anything else?" Excellent question. Here's the answer:

• The job market: some companies use GitLab, others Bitbucket, others still Jenkins. Knowing multiple platforms makes you much more employable.
• Needs vary: an open source project will naturally go to GitHub, but a company with internal servers may prefer self-hosted GitLab.
• Portability: understanding the common concepts lets you switch from one platform to another in hours, not weeks.
• Critical thinking: knowing the alternatives lets you choose the right tool rather than being stuck with a default choice.

GitLab CI/CD - The Imperial Forge

GitLab is often considered GitHub's most complete competitor. Its main strength: everything is integrated. CI/CD, container registry, project management, security - all in a single platform.

The .gitlab-ci.yml file

Like GitHub Actions uses files in .github/workflows/, GitLab uses a single file at the repository root: .gitlab-ci.yml.

stages:
  - test
  - deploy

test:
  stage: test
  script:
    - echo "Running tests..."

deploy:
  stage: deploy
  script:
    - echo "Deploying..."
  only:
    - main

Key concepts of GitLab CI

A more complete example

stages:
  - build
  - test
  - deploy

variables:
  APP_NAME: "my-application"

build:
  stage: build
  script:
    - echo "Building $APP_NAME..."
    - mkdir -p build
    - cp src/*.py build/
  artifacts:
    paths:
      - build/

unit-test:
  stage: test
  script:
    - echo "Running unit tests..."
    - python -m pytest tests/

lint-test:
  stage: test
  script:
    - echo "Checking style..."
    - python -m flake8 src/

deploy:
  stage: deploy
  script:
    - echo "Deploying $APP_NAME..."
  only:
    - main
  when: manual

GitLab's strengths

• All-in-one: CI/CD, Docker container registry, project management, wiki, static pages - everything is natively integrated.
• Self-hosting: you can install GitLab on your own servers. This is a huge advantage for companies that want to keep control of their data.
• Built-in container registry: every GitLab project has its own Docker registry, ready to use.
• Deployment environments: GitLab lets you define environments (staging, production) and visualize deployments directly in the interface.

Bitbucket Pipelines - The Merchant Guilds' Forge

Bitbucket is the forge of the Atlassian ecosystem - the same family as Jira (project management) and Confluence (documentation). If your company uses Jira, Bitbucket integrates naturally.

The bitbucket-pipelines.yml file

Bitbucket also uses a YAML file at the repository root:

pipelines:
  default:
    - step:
        name: Tests
        script:
          - echo "Running tests..."

  branches:
    main:
      - step:
          name: Tests
          script:
            - echo "Running tests..."
      - step:
          name: Deployment
          script:
            - echo "Deploying..."

Key concepts of Bitbucket Pipelines

Example with Pipes

Pipes are a Bitbucket specialty - they are ready-to-use integrations:

pipelines:
  default:
    - step:
        name: Tests
        caches:
          - node
        script:
          - npm install
          - npm test
    - step:
        name: Slack Notification
        script:
          - pipe: atlassian/slack-notify:2.0.0
            variables:
              WEBHOOK_URL: $SLACK_WEBHOOK
              MESSAGE: "Build completed successfully!"

Bitbucket's strengths

• Jira integration: commits and branches are automatically linked to Jira tickets. You create a branch from a ticket, and everything is tracked.
• Pipes: pre-built integrations that simplify common tasks (AWS deployment, notifications, etc.).
• Free private repos: historically, Bitbucket offered free private repos before GitHub.
• Confluence integration: documentation is directly linked to the code.

Other notable forges

The world of forges is not limited to these three giants. Here are other important players:

Jenkins - The Veteran

Jenkins is one of the oldest CI/CD tools. It is entirely self-hosted and extremely flexible.

• Strengths: infinite customization, immense plugin ecosystem (over 1800), free and open source.
• Weaknesses: aging interface, complex configuration, maintenance required.
• Config file: Jenkinsfile (Groovy syntax)

pipeline {
    agent any
    stages {
        stage('Test') {
            steps {
                sh 'echo "Running tests..."'
            }
        }
    }
}

Jenkins remains widely used in large companies that have invested heavily in their infrastructure.

CircleCI - The Cloud Sprinter

CircleCI is a cloud-native CI/CD platform, known for its speed and efficiency.

• Strengths: very fast, excellent Docker support, good interface.
• Weaknesses: cost increases quickly with usage, fewer auxiliary features.
• Config file: .circleci/config.yml

Travis CI - The Open Source Pioneer

Travis CI was historically the favorite CI/CD platform for open source projects. It popularized the concept of CI/CD integrated with forges.

• Strengths: simple to configure, pioneer of GitHub integration.
• Weaknesses: lost popularity after its acquisition, reduced free tier.
• Config file: .travis.yml

Forgejo/Gitea Actions - The Free Alternative

Forgejo and Gitea are self-hosted, lightweight, open source forges. Their Actions system is compatible with GitHub Actions - you can often reuse your workflows directly!

• Strengths: lightweight, self-hosted, GitHub Actions compatible, privacy-respecting.
• Weaknesses: smaller community, fewer third-party actions available.
• Config file: .forgejo/workflows/ or .gitea/workflows/ (same syntax as GitHub Actions)

Comparison table

Here is a summary to help you understand the differences:

How to choose the right platform?

The choice depends on your context. Here's a simple guide:

• Doing open source? - GitHub. The community is there, contributors know the platform.
• Your company wants full internal control? - Self-hosted GitLab. Data on your servers, total customization.
• Your team already uses Jira? - Bitbucket. The native integration with the Atlassian ecosystem saves a lot of time.
• You want a lightweight, free solution? - Forgejo/Gitea. Perfect for a personal server or a small team.
• You have an existing complex system? - Jenkins. Its flexibility is unmatched for special cases.

Portability - The art of not being trapped

A common trap: putting all your CI/CD logic in your platform's YAML file. If you change forges one day, you have to rewrite everything.

The solution? Keep the logic in scripts, not in the YAML.

Bad approach (everything in the YAML)

# .github/workflows/ci.yml - Hard to port
name: CI
on: [push]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: pip install -r requirements.txt
      - run: python -m pytest tests/ --cov=src
      - run: python -m flake8 src/ --max-line-length=120
      - run: echo "All tests pass!"

Good approach (logic in a script)

First, create a scripts/test.sh script:

#!/bin/bash
# scripts/test.sh - The logic is here, not in the YAML
echo "Installing dependencies..."
pip install -r requirements.txt

echo "Running tests..."
python -m pytest tests/ --cov=src

echo "Checking style..."
python -m flake8 src/ --max-line-length=120

echo "All tests pass!"

Then, each YAML file simply calls this script:

# GitHub Actions
- run: bash scripts/test.sh

# GitLab CI
script:
  - bash scripts/test.sh

# Bitbucket Pipelines
script:
  - bash scripts/test.sh

Result: if you change platforms, you only need to rewrite the minimal YAML file. All your logic stays intact.

Hands-on exercise - Forge on three anvils

Step 1 - Create the repository

mkdir multi-forge
cd multi-forge
git init -b main

Step 2 - Create the test script

Create a scripts/ folder and a scripts/test.sh file:

mkdir scripts

Write the content of scripts/test.sh:

#!/bin/bash
# scripts/test.sh - Portable test script

echo "=== Running tests ==="

# Test 1: verify the README file exists
if [ -f "README.md" ]; then
    echo "PASS: README.md exists"
else
    echo "FAIL: README.md missing"
    exit 1
fi

# Test 2: verify the scripts folder exists
if [ -d "scripts" ]; then
    echo "PASS: scripts/ folder exists"
else
    echo "FAIL: scripts/ folder missing"
    exit 1
fi

echo "=== All tests pass ==="

Make it executable:

chmod +x scripts/test.sh

Step 3 - Create a README

echo "# Multi-Forge" > README.md
echo "Multi-platform CI/CD demonstration project." >> README.md

Step 4 - Write the GitHub Actions pipeline

mkdir -p .github/workflows

Content of .github/workflows/ci.yml:

name: CI
on: [push]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run tests
        run: bash scripts/test.sh

Step 5 - Write the GitLab CI pipeline

Content of .gitlab-ci.yml (at the root):

stages:
  - test

test:
  stage: test
  script:
    - bash scripts/test.sh

Step 6 - Write the Bitbucket Pipelines pipeline

Content of bitbucket-pipelines.yml (at the root):

pipelines:
  default:
    - step:
        name: Tests
        script:
          - bash scripts/test.sh

Step 7 - Commit everything

git add .
git commit -m "Add CI pipelines for GitHub, GitLab and Bitbucket"

Step 8 - Run the verification

bash verifier.sh

.\verifier.ps1

Concept summary

Configuration files summary