https://alibaba-cloud.medium.com/how-to-select-a-git-branch-mode-1f8774a8bd94

"La integración continua es una práctica de desarrollo de software en la que cada miembro de un equipo fusiona sus cambios en un código base junto con los cambios de sus colegas al menos diariamente. Cada una de estas integraciones se verifica mediante una compilación automatizada para detectar errores lo más rápido posible"

https://martinfowler.com/articles/continuousIntegration.html

Pipeline de CI/CD

Una pipeline de CI/CD es una serie de pasos que se deben realizar para poner en producción una nueva versión de software

En la actualidad, se tiende a ejecutar una pipeline completa cada día

Podéis configurar el control de versiones (GitHub, GitLab...) para que ejecute una pipeline después de un evento de Git, especialmente commit y merge

https://www.redhat.com/en/topics/devops/what-cicd-pipeline

El CI/CD se estructura en "pipelines": "jobs" autoáticos que se ejecutan uno después de otro

https://testrigor.com/blog/what-is-cicd/

Responsabilidad de una pipeline

1. Cada commit debería ejecutar todas las herramientas automáticas de detección de errores
2. Repara inmediatamente los errores de compilación
3. Repara los errores de seguridad
4. La ejecución de todas estas pruebas debe ser rápida...
5. ...y automática
6. Automatiza también el despliegue de la aplicación

Ejemplos:

Terminología

• Pipeline: conjunto de etapas que se ejecutan cuando sucede algo en un proyecto. Por ejemplo, cuando se hace un "git push"
• Jobs: comandos que hay que ejecutar. Por ejemplo: linters, analizadores estáticos...
• Stages: etapa en las que se ejecuta un conjunto de jobs. En gitlab, todos los jobs de una etapa se ejecutan en paralelo. La ejecución puede pararse si falla algún job dentro de un stage.
• Runners: máquinas que ejecutan los jobs. Generalmente son un servidor docker que ejecuta una imagen determinada
• Artifacts: archivos que se generan al final de un job. En nuestro caso, son los reportes de las herramientas de seguridad, o los archivos .exe que se pasan a la etapa siguiente.

Etapas/Stages comunes

• Build: en esta etapa se realiza la compilación del código. Herramientas: Maven, Gradle...
• Tests: la prueba de todas las unidades se realiza en esta etapa. Entonces, sabremos dónde exactamente el código tiene errores y, si se encuentran errores, no se continúa a las siguientes etapas. Herramientas: linters, Selenium, PYtest...
• Integrar: en esta etapa, se juntan las piezas del código y librerías
• Staging: en esta etapa, el código se despliega en un entorno de pruebas, para análisis dinámico.
• Despliegue: en esta etapa, el código se despliega en el entorno del cliente. Ejemplos: AWS, Docker...
• Operar: las operaciones se realizan en el código si es necesario.Herramienta: Kubernetes, OpenShift...
• Monitor: en esta etapa, el monitoreo de la aplicación se realiza aquí en el entorno del cliente. Herramientas: Nagios, ELK, Splunk, Grafana...

https://resources.github.com/ci-cd/

https://bwgjoseph.com/how-to-setup-and-configure-your-own-gitlab-runner

Ejemplo: esta misma presentación

Cada vez que modifico algo en esta presentación, hay una pipeline que automáticamente:

• CI: compila el código Markdown a HTML
• CD: publica el código HTML en la web

https://github.com/Juanvvc/securecoding/tree/main/.github/workflows

Jobs ejecutados

Observa: la compilación se hace a través de una contenedor docker

Ejemplo en GitLab

stages:   # Dictionary
 - build   # this is build stage
 - test    # this is test stage
 - integration # this is an integration stage
 - prod       # this is prod/production stage

build:       # this is job named build, it can be anything, job1, job2, etc.,
  stage: build    # this job belongs to the build stage. Here both job name and stage name is the same i.e., build
  script:
    - echo "This is a build step"  # We are running an echo command, but it can be any command.
    - echo "{\"vulnerability\":\"SQL Injection\"}" > output.json
  artifacts:      # notice a new tag artifacts
    paths: [output.json]   # this is the path to the output.json file
    when: always  # when the artifact is included: always|on_failure|on_success
    expire_in: never # 2 hrs|3 weeks|6 mos

test:
  stage: test
  script:
    - echo "This is a test step."
    - exit 1         # Non zero exit code, fails a job.
  allow_failure: true   #<--- allow the build to fail but don't mark it as such

integration:        # integration job under stage integration.
  stage: integration
  script:
    - echo "This is an integration step."

prod:
  stage: prod
  script:
    - echo "This is a deploy step."
  when: man

Ejemplo: integrando bandit en CI/CD

1. Crea un nuevo proyecto en gitlab.com: New Project -> Import
2. Importa desde URL: https://github.com/NetSPI/django.nV
3. Menú de la izquierda: Build -> Pipeline editor, o edita directamente el archivo .gitlab-ci.yml

Sustituye .gitlab-ci.yml en Build -> Pipeline editor. Quita los caracteres \\, no cabía la línea entera en esta transparencia.

image: docker:20.10

services:
  - docker:dind

stages:
  - build
  - test
  - deploy

sast:
  stage: build
  script:
    - docker pull hysnsec/bandit
    - docker run --user $(id -u):$(id -g) -v $(pwd):/src --rm \\
    hysnsec/bandit -r /src -f json -o /src/bandit-output.json
  artifacts:
    paths: [bandit-output.json]
    when: always
  allow_failure: true

Busca la ejecución en el menú izquierdo, Build -> Pipelines

Observa los artefactos y que la pipeline ha fallado. allow_failure: true permite ejecutar otros jobs después, si los hubiese

Más ejemplos: comprueba si hay secretos con trufflehog. Quita los caracteres \\, no cabía la línea entera en esta transparencia.

git-secrets:
  stage: build
  script:
    - docker run --user $(id -u):$(id -g) -v $(pwd):/src --rm \\
    hysnsec/trufflehog filesystem --directory=/src --json \\
    | tee trufflehog-output.json
    - docker run --user $(id -u):$(id -g) -v $(pwd):/src --rm \\
    hysnsec/trufflehog filesystem --directory=/src --json \\
    | tee trufflehog-output.json
  artifacts:
    paths: [trufflehog-output.json]
    when: always
    expire_in: one week
  allow_failure: true

Más ejemplos: NMAP

# DAST using nmap, during integration stage
dast-nmap:
  stage: integration
  script:
    - docker pull hysnsec/nmap
    - docker run --rm --user $(id -u):$(id -g) -v $(pwd):/tmp hysnsec/nmap $PROD_SERVER -oX /tmp/nmap-output.xml
  artifacts:
    paths: [nmap-output.xml]
    when: always
    expire_in: one week
  allow_failure: true

Gestión de secretos

En el ejemplo anterior, fíjate en la variable: PROD_SERVER

Puedes gestionar variables en Settings -> Variables

Ejemplos: inspec

inspec:
  stage: prod
  only:
    - main
  environment: production
  before_script:
    - mkdir -p ~/.ssh
    - echo "$DEPLOYMENT_SERVER_SSH_PRIVKEY" | tr -d '\r' > ~/.ssh/id_rsa
    - chmod 600 ~/.ssh/id_rsa
    - eval "$(ssh-agent -s)"
    - ssh-add ~/.ssh/id_rsa
    - ssh-keyscan -t rsa $DEPLOYMENT_SERVER >> ~/.ssh/known_hosts
  script:
    - docker run --rm -v ~/.ssh:/root/.ssh -v $(pwd):/share \\
    hysnsec/inspec exec https://github.com/dev-sec/linux-baseline \\
    -t ssh://root@$DEPLOYMENT_SERVER -i ~/.ssh/id_rsa \\
    --chef-license accept --reporter json:/share/inspec-output.json
  artifacts:
    paths: [inspec-output.json]
    when: always

Defect Dojo

https://www.defectdojo.org/

Gestión de vulnerabilidades e informes de CI/CD

Ejemplos: enviar los artefactos de los jobs anteriores a DefectDojo

sast:
  stage: build
  before_script:
    - apk add py-pip py-requests
  script:
    - docker pull hysnsec/bandit
    - docker run --user $(id -u):$(id -g) -v $(pwd):/src --rm \\
    hysnsec/bandit -r /src -f json -o /src/bandit-output.json
  after_script:
    - python3 upload-results.py --host $DOJO_HOST \\
    --api_key $DOJO_API_TOKEN --engagement_id 1 \\
    --product_id 1 --lead_id 1 --environment "Production" \\
    --result_file bandit-output.json --scanner "Bandit Scan"
  artifacts:
    paths: [bandit-output.json]
    when: always

Referencias

• Continuous Integration, Martin Fowler
• CI/CD: The what, why, and how
• What is CI/CD?
• Introducción a CI/CD con GitLab (video)
• CI/CD Pipeline: A Gentle Introduction
• CI/CD en Gitlab
• CI/CD en Github