Skip to main content
skill CX Codex

building-devsecops-pipeline-with-gitlab-ci — GitLab CI skill: setup

building-devsecops-pipeline-with-gitlab-ci is a Claude Code skill that adds security checks for code, dependencies, containers, and secrets to GitLab CI/CD. Checks run before deployment.

Apache-2.0 243 installs ★ 36,511 updated 2026-08-31

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add mukul975/Anthropic-Cybersecurity-Skills --skill building-devsecops-pipeline-with-gitlab-ci -a claude-code
Open on GitHub

What building-devsecops-pipeline-with-gitlab-ci does

This skill guides you through adding security stages to .gitlab-ci.yml: SAST, DAST, container and dependency scanning, and secret detection. The SAST examples name Semgrep, SpotBugs, Gosec, Bandit, and NodeJsScan; container scanning uses Trivy. GitLab-managed templates provide the scanner jobs.

The sample pipeline runs checks before deployment and targets a staging app with DAST. It also covers custom SAST rules and policies for vulnerability approvals. The full scanner suite requires a GitLab Ultimate license and a configured GitLab Runner. DAST needs an accessible staging target URL, so it cannot scan an app that has not been deployed there.

What it helps with

  • add SAST and secret detection to .gitlab-ci.yml
  • scan container images for known vulnerabilities
  • check project dependencies before deployment
  • run DAST against a staging application
  • require approval for critical vulnerabilities

Example prompts for the agent

  • Add SAST, container scanning, and secret detection stages to .gitlab-ci.yml.
  • Set up DAST to scan the app after it is deployed to staging.
  • Show me how to define SAST rules and approval policies for critical findings.

How to install building-devsecops-pipeline-with-gitlab-ci

1Skills CLI (Vercel)

npx skills add mukul975/Anthropic-Cybersecurity-Skills --skill building-devsecops-pipeline-with-gitlab-ci -a claude-code

2Manually: put the files in place

~/.claude/skills/building-devsecops-pipeline-with-gitlab-ci/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/building-devsecops-pipeline-with-gitlab-ci/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about building-devsecops-pipeline-with-gitlab-ci

How do I install building-devsecops-pipeline-with-gitlab-ci in Claude Code?

Run npx skills add mukul975/Anthropic-Cybersecurity-Skills --skill building-devsecops-pipeline-with-gitlab-ci -a claude-code. The skill file is placed at ~/.claude/skills/building-devsecops-pipeline-with-gitlab-ci/SKILL.md.

What does building-devsecops-pipeline-with-gitlab-ci do?

It helps add code, dependency, container, and secret checks to GitLab CI/CD, along with DAST for an app in staging.

What does DAST need in a GitLab pipeline?

The application must be deployed and reachable at a target URL. The example runs DAST after the staging deployment.

Source text

SKILL.md · Apache-2.0
---
name: building-devsecops-pipeline-with-gitlab-ci
description: Configure a GitLab CI/CD pipeline that embeds SAST (Semgrep, SpotBugs, Gosec, Bandit, NodeJsScan), DAST, container scanning, dependency scanning, and secret detection via GitLab's managed security templates. Use when building a shift-left DevSecOps pipeline in GitLab, adding automated vulnerability scanning stages to .gitlab-ci.yml, or triaging scanner findings with GitLab Duo AI before deployment.
domain: cybersecurity
subdomain: devsecops
tags:
- gitlab-ci
- devsecops
- sast
- dast
- container-scanning
- dependency-scanning
- secret-detection
- cicd-security
version: '1.0'
author: mahipal
license: Apache-2.0
nist_csf:
- PR.PS-01
- GV.SC-07
- ID.IM-04
- PR.PS-04
mitre_attack:
- T1195.001
- T1195.002
- T1552.001
- T1190
- T1610
---

# Building DevSecOps Pipeline with GitLab CI

## Overview

GitLab provides an integrated DevSecOps platform that embeds security testing directly into the CI/CD pipeline. By leveraging GitLab's built-in security scanners---SAST, DAST, container scanning, dependency scanning, secret detection, and license compliance---teams can shift security left, catching vulnerabilities during development rather than post-deployment. GitLab Duo AI assists with false positive detection for SAST vulnerabilities, helping security teams focus on genuine issues.


## When to Use

- When deploying or configuring building devsecops pipeline with gitlab ci capabilities in your environment
- When establishing security controls aligned to compliance requirements
- When building or improving security architecture for this domain
- When conducting security assessments that require this implementation

## Prerequisites

- GitLab Ultimate license (required for full security scanner suite)
- GitLab Runner configured (shared or self-hosted)
- `.gitlab-ci.yml` pipeline configuration familiarity
- Docker-in-Docker (DinD) or Kaniko for container builds
- Application deployed to a staging environment for DAST scanning

## Core Security Scanning Stages

### Static Application Security Testing (SAST)

SAST analyzes source code for vulnerabilities before compilation. GitLab supports 14+ languages using analyzers such as Semgrep, SpotBugs, Gosec, Bandit, and NodeJsScan. The simplest inclusion uses GitLab's managed templates.

### Dynamic Application Security Testing (DAST)

DAST tests running applications by simulating attack payloads against HTTP endpoints. It detects XSS, SQLi, CSRF, and other runtime vulnerabilities that static analysis cannot find. DAST requires a deployed, accessible target URL.

### Container Scanning

Uses Trivy to scan Docker images for known CVEs in OS packages and application dependencies. Runs after the Docker build stage to gate images before they reach a registry.

### Dependency Scanning

Inspects dependency manifests (package.json, requirements.txt, pom.xml, Gemfile.lock) for known vulnerable versions. Operates at the source code level, complementing container scanning.

### Secret Detection

Scans commits for accidentally committed credentials, API keys, tokens, and private keys using pattern matching and entropy analysis. Runs on every commit to prevent secrets from reaching the repository.

## Implementation

### Complete Pipeline Configuration

```yaml
# .gitlab-ci.yml

stages:
  - build
  - test
  - security
  - deploy-staging
  - dast
  - deploy-production

variables:
  DOCKER_IMAGE: $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA
  SECURE_LOG_LEVEL: "info"

# Include GitLab managed security templates
include:
  - template: Security/SAST.gitlab-ci.yml
  - template: Security/Secret-Detection.gitlab-ci.yml
  - template: Security/Dependency-Scanning.gitlab-ci.yml
  - template: Security/Container-Scanning.gitlab-ci.yml
  - template: DAST.gitlab-ci.yml
  - template: Security/License-Scanning.gitlab-ci.yml

build:
  stage: build
  image: docker:24.0
  services:
    - docker:24.0-dind
  variables:
    DOCKER_TLS_CERTDIR: "/certs"
  script:
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
    - docker build -t $DOCKER_IMAGE .
    - docker push $DOCKER_IMAGE
  rules:
    - if: $CI_COMMIT_BRANCH

unit-tests:
  stage: test
  image: $DOCKER_IMAGE
  script:
    - npm ci
    - npm run test:coverage
  coverage: '/Lines\s*:\s*(\d+\.?\d*)%/'
  artifacts:
    reports:
      junit: junit-report.xml
      coverage_report:
        coverage_format: cobertura
        path: coverage/cobertura-coverage.xml

# Override SAST to run in security stage
sast:
  stage: security
  variables:
    SAST_EXCLUDED_PATHS: "spec,test,tests,tmp,node_modules"
    SEARCH_MAX_DEPTH: 10

# Override container scanning
container_scanning:
  stage: security
  variables:
    CS_IMAGE: $DOCKER_IMAGE
    CS_SEVERITY_THRESHOLD: "HIGH"

# Override dependency scanning
dependency_scanning:
  stage: security

# Override secret detection
secret_detection:
  stage: security

# License compliance scanning
license_scanning:
  stage: security

deploy-staging:
  stage: deploy-staging
  image: bitnami/kubectl:latest
  script:
    - kubectl set image deployment/app app=$DOCKER_IMAGE -n staging
    - kubectl rollout status deployment/app -n staging --timeout=300s
  environment:
    name: staging
    url: https://staging.example.com
  rules:
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH

# DAST runs against deployed staging
dast:
  stage: dast
  variables:
    DAST_WEBSITE: https://staging.example.com
    DAST_FULL_SCAN_ENABLED: "true"
    DAST_BROWSER_SCAN: "true"
  needs:
    - deploy-staging
  rules:
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH

deploy-production:
  stage: deploy-production
  image: bitnami/kubectl:latest
  script:
    - kubectl set image deployment/app app=$DOCKER_IMAGE -n production
    - kubectl rollout status deployment/app -n production --timeout=300s
  environment:
    name: production
    url: https://app.example.com
  when: manual
  rules:
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
```

### Security Approval Policies

Configure scan execution policies to enforce mandatory security scans:

1. Navigate to Security & Compliance > Policies
2. Create a "Scan Execution Policy" requiring SAST and secret detection on all branches
3. Create a "Merge Request Approval Policy" requiring security team approval when critical vulnerabilities are detected

### Custom SAST Ruleset Configuration

Create `.gitlab/sast-ruleset.toml` to customize analyzer behavior:

```toml
[semgrep]
  [[semgrep.ruleset]]
    dirs = ["src"]

  [[semgrep.passthrough]]
    type = "url"
    target = "/sgrep-rules/custom-rules.yml"
    value = "https://semgrep.dev/p/owasp-top-ten"

  [[semgrep.passthrough]]
    type = "url"
    target = "/sgrep-rules/java-rules.yml"
    value = "https://semgrep.dev/p/java"
```

## Security Dashboard and Vulnerability Management

### Vulnerability Report

GitLab consolidates all scanner findings into a single Vulnerability Report accessible at Security & Compliance > Vulnerability Report. Each vulnerability includes:
- Severity rating (Critical, High, Medium, Low, Info)
- Scanner source (SAST, DAST, Container, Dependency, Secret)
- Location in source code or image layer
- Remediation guidance and suggested fixes
- Status tracking (Detected, Confirmed, Dismissed, Resolved)

### Merge Request Security Widget

Every merge request displays a security scanning widget showing:
- New vulnerabilities introduced by the MR
- Fixed vulnerabilities resolved by the MR
- Comparison against the target branch baseline

## Pipeline Optimization

- **Parallel execution**: Security scanners run concurrently in the security stage
- **Caching**: Use CI cache for dependency downloads to speed up scanning
- **Incremental scanning**: SAST can scan only changed files using `SAST_INCREMENTAL: "true"`
- **Fail conditions**: Set `allow_failure: false` on critical scanners to enforce quality gates

## Monitoring and Metrics

| Metric | Description | Target |
|--------|-------------|--------|
| Pipeline security coverage | Percentage of projects with all scanners enabled | > 95% |
| Critical vulnerability MTTR | Time from detection to resolution for critical findings | < 48 hours |
| False positive rate | Percentage of dismissed-as-false-positive findings | < 15% |
| Secret detection block rate | Percentage of secret commits blocked by push rules | > 99% |

## References

- [GitLab Security Scanning Documentation](https://docs.gitlab.com/ee/user/application_security/)
- [GitLab SAST Analyzers](https://docs.gitlab.com/ee/user/application_security/sast/)
- [GitLab DAST Configuration](https://docs.gitlab.com/ee/user/application_security/dast/)
- [GitLab Security Policies](https://docs.gitlab.com/ee/user/application_security/policies/)
- [GitLab Vulnerability Management](https://docs.gitlab.com/ee/user/application_security/vulnerability_report/)

© mahipal · Apache-2.0 · mukul975/Anthropic-Cybersecurity-Skills

Similar skills

All skills for Security →

From the same set152

The whole set →
analyzing-windows-event-logs-in-splunk analyzing-windows-event-logs-in-splunk is a Claude Code skill for inspecting Windows Security, System and Sysmon logs in Splunk and mapping events to MITRE ATT&CK. CX Codex +1 251installs analyzing-windows-registry-for-artifacts analyzing-windows-registry-for-artifacts is a Claude Code skill that extracts and examines Windows Registry hives during incident response, tracing autostart keys, USB history, and program execution artifacts. CX Codex +1 248installs detecting-api-enumeration-attacks detecting-api-enumeration-attacks is a Claude Code skill that builds SIEM detections for API identifier probing and access-control abuse. It is used during BOLA/IDOR investigations and threat hunting. CX Codex +1 246installs conducting-full-scope-red-team-engagement conducting-full-scope-red-team-engagement is a Claude Code skill that plans MITRE ATT&CK red team operations. It triggers on requests to assess defenses against APT attacks or emulate a threat actor. CX Codex +1 243installs auditing-azure-active-directory-configuration auditing-azure-active-directory-configuration audits Microsoft Entra ID security using Microsoft Graph API, Az CLI, and ScoutSuite. It finds over-privileged roles, Conditional Access gaps, and stale accounts. CX Codex +1 241installs auditing-gcp-iam-permissions auditing-gcp-iam-permissions audits GCP IAM for broad bindings, primitive roles, service account keys, and cross-project access. Use it when reviewing permissions or reducing credential blast radius. CX Codex +1 241installs analyzing-usb-device-connection-history analyzing-usb-device-connection-history reconstructs USB device connection history on Windows systems using registry hives and event logs. Built for incident response and insider threat audits. CX Codex +1 241installs performing-api-security-testing-with-postman performing-api-security-testing-with-postman is a skill that builds structured Postman test suites for OWASP API Security Top 10 and automates checks in CI/CD with Newman. CX Codex +1 240installs

More in the catalog

Project sponsors

Companies that keep this analytics open