Skip to content
Skillpedia
Deploy & cloud (DevOps)48k · #3140

gitlab-ci

Configures GitLab CI/CD pipelines and runners. It automates the building, testing, and deployment of software.

What it does

This tool helps set up and automate software delivery processes using GitLab CI/CD. It allows you to create steps for automatically building, testing, and deploying your code.

When to use it

  • ✓When setting up GitLab's continuous delivery system.
  • ✓When defining how code will be automatically tested and deployed.
  • ✓When managing the tools that run these automated tasks.

Example of what to ask your AI

“Set up a pipeline to build, test, and deploy my Node.js app on the main branch.”

Want more? Open the sections below.

How to use

The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.

Skill link

https://github.com/sickn33/agentic-awesome-skills/blob/main/plugins/agentic-awesome-skills-claude/skills/gitlab-ci/SKILL.md

Ready-to-paste message

Use this skill to help me: https://github.com/sickn33/agentic-awesome-skills/blob/main/plugins/agentic-awesome-skills-claude/skills/gitlab-ci/SKILL.md Read the SKILL.md file at that link and follow its instructions for my task.
How it works

You define stages and jobs in a file named `.gitlab-ci.yml`. This file describes what to do, in what order, and with which tools.

Installation

Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.

In the terminal (Claude Code, Codex, Cursor), in your project folder:

npx skills add sickn33/agentic-awesome-skills --skill gitlab-ci

Or download just the file:

curl -L https://raw.githubusercontent.com/sickn33/agentic-awesome-skills/main/plugins/agentic-awesome-skills-claude/skills/gitlab-ci/SKILL.md -o SKILL.md
Technical content (original SKILL.md)

Original text by the author, straight from GitHub.

GitLab CI/CD

Automate your software delivery pipeline with GitLab's integrated CI/CD system.

When to Use This Skill

Use this skill when:

  • Setting up CI/CD pipelines in GitLab
  • Configuring GitLab runners (shared or self-hosted)
  • Creating multi-stage deployment pipelines
  • Implementing GitLab Auto DevOps
  • Managing CI/CD variables and secrets

Prerequisites

  • GitLab repository (gitlab.com or self-hosted)
  • Basic understanding of YAML
  • For self-hosted runners: Linux server or Kubernetes cluster

Pipeline Configuration

Create .gitlab-ci.yml in repository root:

stages:
  - build
  - test
  - deploy

variables:
  NODE_VERSION: "20"

build:
  stage: build
  image: node:${NODE_VERSION}
  script:
    - npm ci
    - npm run build
  artifacts:
    paths:
      - dist/
    expire_in: 1 hour

test:
  stage: test
  image: node:${NODE_VERSION}
  script:
    - npm ci
    - npm test
  coverage: '/Coverage: \d+\.\d+%/'

deploy:
  stage: deploy
  script:
    - ./deploy.sh
  environment:
    name: production
    url: https://example.com
  only:
    - main

Job Configuration

Rules-Based Execution

deploy:
  script: ./deploy.sh
  rules:
    - if: $CI_COMMIT_BRANCH == "main"
      when: manual
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
      when: never
    - when: on_success

Parallel Jobs

test:
  stage: test
  parallel: 3
  script:
    - npm test -- --shard=$CI_NODE_INDEX/$CI_NODE_TOTAL

Matrix Builds

test:
  stage: test
  parallel:
    matrix:
      - NODE_VERSION: ["18", "20", "22"]
        OS: ["alpine", "slim"]
  image: node:${NODE_VERSION}-${OS}
  script:
    - npm test

Caching

cache:
  key:
    files:
      - package-lock.json
  paths:
    - node_modules/
  policy: pull-push

build:
  cache:
    key: build-cache
    paths:
      - .cache/
    policy: pull

Artifacts

build:
  artifacts:
    paths:
      - dist/
      - coverage/
    reports:
      junit: junit.xml
      coverage_report:
        coverage_format: cobertura
        path: coverage/cobertura.xml
    expire_in: 1 week
    when: always

Environments and Deployments

deploy_staging:
  stage: deploy
  script:
    - deploy --env staging
  environment:
    name: staging
    url: https://staging.example.com
    on_stop: stop_staging

stop_staging:
  stage: deploy
  script:
    - undeploy --env staging
  environment:
    name: staging
    action: stop
  when: manual

Docker Builds

build_image:
  stage: build
  image: docker:24
  services:
    - docker:24-dind
  variables:
    DOCKER_TLS_CERTDIR: "/certs"
  script:
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
    - docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA .
    - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA

GitLab Runners

Install Runner

# Download and install
curl -L https://packages.gitlab.com/install/repositories/runner/gitlab-runner/script.deb.sh | sudo bash
sudo apt install gitlab-runner

# Register runner
sudo gitlab-runner register \
  --url https://gitlab.com/ \
  --registration-token TOKEN \
  --executor docker \
  --docker-image alpine:latest

Runner Configuration

# /etc/gitlab-runner/config.toml
[[runners]]
  name = "docker-runner"
  url = "https://gitlab.com/"
  token = "TOKEN"
  executor = "docker"
  [runners.docker]
    image = "alpine:latest"
    privileged = true
    volumes = ["/cache", "/var/run/docker.sock:/var/run/docker.sock"]

Runner Tags

build:
  tags:
    - docker
    - linux
  script:
    - make build

CI/CD Variables

Protected Variables

Define in Settings > CI/CD > Variables:

  • AWS_ACCESS_KEY_ID (protected, masked)
  • AWS_SECRET_ACCESS_KEY (protected, masked)

Using Variables

deploy:
  script:
    - aws s3 sync dist/ s3://$S3_BUCKET
  variables:
    AWS_DEFAULT_REGION: us-east-1

Include and Extend

Include Templates

include:
  - template: Security/SAST.gitlab-ci.yml
  - project: 'group/shared-ci'
    file: '/templates/deploy.yml'
  - local: '/ci/jobs.yml'

Extend Jobs

.base_job:
  image: node:20
  before_script:
    - npm ci

build:
  extends: .base_job
  script:
    - npm run build

test:
  extends: .base_job
  script:
    - npm test

Multi-Project Pipelines

trigger_downstream:
  stage: deploy
  trigger:
    project: group/downstream-project
    branch: main

…
FAQ

What are 'runners'?

Runners are the agents that execute the tasks defined in your pipeline. They can be configured within GitLab or on your own servers.

What are 'artifacts'?

Artifacts are files produced by a job, like the output of your code build, which can be used by other jobs or downloaded.

What are 'stages'?

Stages are the main phases of your pipeline, such as 'build', 'test', and 'deploy'. Jobs within a stage run in parallel, and stages run sequentially.

Details

Original description by the author

Configure GitLab CI/CD pipelines and runners for automated building, testing, and deployment.

repo: sickn33/agentic-awesome-skills

Popularity

GitHub stars
48k
Ranking position
#3140
License
MIT
Updated
10/15/2026

Is this skill useful?

0

Sign in to vote.

Comments

  • …

More skills from this repository

Similar skills