Precise Branch and Tag Control in GitLab CI Using Regular Expressions and Rules Engine

Core Principles of GitLab CI Trigger Mechanisms

In GitLab CI/CD pipeline configuration, precisely controlling triggers for specific branches and tags is crucial for achieving efficient automated deployment. GitLab provides multiple mechanisms to accomplish this, with the most commonly used being the only field and the rules rules engine. Understanding how these mechanisms work is essential for configuring precise trigger conditions.

Application of Regular Expressions in the only Field

Addressing the user's requirement—to trigger the project_dev job only for the develop, release, and master branches, as well as specific tag formats like dev_1.0, dev_1.1, and dev_1.2—we can use regular expressions to achieve exact matching. The issue in the original configuration arose from using an overly broad regular expression /^dev_[0-9.]*$/, which would incorrectly match tags like dev1.2.

The correct regular expression should precisely match the pattern of dev_ followed by numbers and dots: /^dev_[0-9]+(?:.[0-9]+)+$/. The meaning of this expression is:

• ^dev_: Starts with "dev_"
• [0-9]+: At least one digit
• (?:.[0-9]+)+: Non-capturing group, matching a dot followed by at least one digit, with this pattern repeatable one or more times

A complete configuration example is as follows:

project_dev:
  stage: dev
  script:
    - export
    - bundle exec pod repo update
    - bundle exec pod install
    - bundle exec fastlane crashlytics_project_dev
  after_script:
    - rm -rf ~/Library/Developer/Xcode/Archives || true
  when: manual
  only:
    - develop
    - release
    - master
    - /^dev_[0-9]+(?:.[0-9]+)+$/
  tags:
    - iOS

Alternative Approach Using Rules Engine

In addition to the only field, GitLab provides a more powerful rules rules engine. This method offers greater flexibility in conditional judgments, particularly suitable for complex trigger logic. When using rules, we can directly access GitLab's predefined environment variables, such as CI_COMMIT_BRANCH and CI_COMMIT_TAG.

A rule-based configuration example is as follows:

project_dev:
  stage: dev
  script:
    - export
    - bundle exec pod repo update
    - bundle exec pod install
    - bundle exec fastlane crashlytics_project_dev
  after_script:
    - rm -rf ~/Library/Developer/Xcode/Archives || true
  when: manual
  rules:
    - if: '$CI_COMMIT_BRANCH =~ /^dev_[0-9]+\.[0-9]+$/ || $CI_COMMIT_TAG =~ /^dev_[0-9]+\.[0-9]+$/'
  tags:
    - iOS

The advantages of this approach include:

1. Clearer logic expression: Using if conditional statements makes the logic more intuitive
2. Support for complex condition combinations: Multiple conditions can be combined using logical operators
3. Better maintainability: Easier modifications when trigger conditions change

Regular Expression Syntax Details

GitLab CI/CD uses a regular expression engine based on RE2 syntax, which guarantees linear time complexity. When writing regular expressions, the following points should be noted:

1. Escape character handling: In strings, the dot . must be escaped as \. to match the literal dot

2. Boundary matching: Use ^ and $ to ensure matching the entire string, avoiding partial matches

3. Quantifier usage: + means at least one, * means zero or more; choose based on actual requirements

Practical Testing and Verification

To verify the correctness of regular expressions, it is recommended to create test tags in actual projects for validation. Testing can be conducted through the following steps:

1. Create test tags: dev_1.0, dev_1.1, dev1.2, etc.
2. Observe pipeline trigger behavior
3. Adjust regular expressions until requirements are met

Test results show that when using the /^dev_[0-9]+(?:.[0-9]+)+$/ regular expression:

• Correctly triggers tags like dev_1.0, dev_1.1
• Does not trigger tags like dev1.2 that do not match the format
• Continues to support triggers for develop, release, and master branches

Best Practice Recommendations

Based on the above analysis, we propose the following best practice recommendations:

1. For simple trigger conditions, using the only field with regular expressions is appropriate

2. For complex logical conditions, using the rules rules engine is recommended for better readability and maintainability

3. Always test regular expressions in actual environments to ensure matching behavior meets expectations

4. Consider using GitLab's predefined environment variables for more precise contextual information

5. Document configuration logic to facilitate team collaboration and future maintenance

By appropriately selecting and applying these techniques, developers can build precise yet flexible CI/CD trigger mechanisms, improving development efficiency and deployment quality.