Melhorando Pipelines no Bitbucket: Cache, Reutilização de Steps e Execução Paralela
Tags: pipeline, bitbucket, cicd, tutorial
Published: 2024-06-11 20:05:32

### Introdução

Bitbucket Pipelines é uma ferramenta poderosa para integração contínua (CI) e entrega contínua (CD) que permite automatizar a construção, teste e implantação do seu código. Neste artigo, vamos explorar técnicas avançadas para otimizar suas pipelines no Bitbucket, incluindo o uso de cache, reutilização de steps e execução paralela de steps.

### Benefícios das Técnicas Avançadas

1. **Uso de Cache**: Reduz o tempo de execução da pipeline armazenando dependências entre builds.
2. **Reutilização de Steps**: Facilita a manutenção e reduz a repetição de código.
3. **Execução Paralela de Steps**: Diminui o tempo total de execução ao rodar múltiplos steps simultaneamente.

### Configuração Básica

Vamos começar com uma configuração básica que utilizaremos como base para implementar as melhorias.

```yaml
image: node:14

options:
  max-time: 5 # Limite de tempo para cada pipeline, em minutos

pipelines:
  default: # Pipeline default
    - step:
        name: Install dependencies
        caches:
          - node
        script:
          - npm install
    - step:
        name: Run lint
        caches:
          - node
        script:
          - npm run lint
    - step:
        name: Run tests
        caches:
          - node
        script:
          - npm test
    - step:
        name: Run prettier
        caches:
          - node
        script:
          - npm run prettier
    - step:
        name: Build
        caches:
          - node
        script:
          - npm run build

  pull-requests: # Rodar essa pipeline na PR
    '**':
      - step:
          name: Install dependencies
          caches:
            - node
          script:
            - npm install
      - parallel:
          - step:
              name: Run lint
              caches:
                - node
              script:
                - npm run lint
          - step:
              name: Run tests
              caches:
                - node
              script:
                - npm test
          - step:
              name: Run prettier
              caches:
                - node
              script:
                - npm run prettier
      - step:
          name: Build
          caches:
            - node
          script:
            - npm run build
```

### Implementando o Cache

Para usar cache de forma eficiente, vamos armazenar o diretório `node_modules` entre builds. Isso economiza tempo ao evitar reinstalações desnecessárias de dependências.

```yaml
definitions:
  caches:
    node: ./node_modules
```

### Reutilização de Steps

Para evitar repetição de código, definimos steps reutilizáveis em uma seção de definições. Aqui está um exemplo de steps comuns como instalação de dependências, lint, testes, prettier e build.

```yaml
definitions:
  steps:
    - step: &install-dependencies
        name: Install dependencies
        caches:
          - node
        script:
          - npm install

    - step: &lint
        name: Run lint
        caches:
          - node
        script:
          - npm run lint

    - step: &test
        name: Run tests
        caches:
          - node
        script:
          - npm test

    - step: &prettier
        name: Run prettier
        caches:
          - node
        script:
          - npm run prettier

    - step: &build
        name: Build
        caches:
          - node
        script:
          - npm run build
```

### Execução Paralela de Steps

Para reduzir o tempo total de execução da pipeline, podemos rodar certos steps em paralelo. A execução paralela é especialmente útil para tasks que não dependem uma da outra, como linting, testes e formatação de código.

### Pipeline Final

Aqui está o arquivo `bitbucket-pipelines.yml` completo, implementando cache, reutilização de steps e execução paralela:

```yaml
image: node:14

options:
  max-time: 5 # Limite de tempo para cada pipeline, em minutos

definitions:
  caches:
    node: ./node_modules

  steps:
    - step: &install-dependencies
        name: Install dependencies
        caches:
          - node
        script:
          - npm install

    - step: &lint
        name: Run lint
        caches:
          - node
        script:
          - npm run lint

    - step: &test
        name: Run tests
        caches:
          - node
        script:
          - npm test

    - step: &prettier
        name: Run prettier
        caches:
          - node
        script:
          - npm run prettier

    - step: &build
        name: Build
        caches:
          - node
        script:
          - npm run build

pipelines:
  default: # Pipeline default
    - step: *install-dependencies
    - parallel: # Rodar comandos em paralelo
        - step: *lint
        - step: *prettier
    - step: *build

  pull-requests: # Rodar essa pipeline na PR
    '**':
      - step: *install-dependencies
      - parallel: # Rodar comandos em paralelo
          - step: *lint
          - step: *test
          - step: *prettier
      - step: *build
```

### Benefícios das Melhorias

1. **Uso de Cache**:
   - **Benefício**: Reduz o tempo de execução das builds ao evitar reinstalações desnecessárias de dependências.
   - **Como funciona**: Armazena o diretório `node_modules` entre builds, fazendo com que apenas novas dependências sejam instaladas.

2. **Reutilização de Steps**:
   - **Benefício**: Facilita a manutenção e reduz a duplicação de código, tornando a configuração mais limpa e gerenciável.
   - **Como funciona**: Define steps comuns em uma seção de definições e os referencia em diferentes pipelines.

3. **Execução Paralela de Steps**:
   - **Benefício**: Diminui o tempo total de execução ao rodar múltiplos steps simultaneamente, acelerando o feedback para os desenvolvedores.
   - **Como funciona**: Usa a palavra-chave `parallel` para rodar steps que não dependem uns dos outros ao mesmo tempo.

### Conclusão

Implementar cache, reutilização de steps e execução paralela em suas pipelines no Bitbucket pode trazer grandes melhorias em eficiência e manutenção. Essas práticas ajudam a otimizar o tempo de execução, reduzir a repetição de código e fornecer feedback mais rápido para os desenvolvedores, melhorando o fluxo de trabalho de CI/CD.


Caso queira dar uma olhadinha no código, segue o link do repositório:

[Node-Example](https://bitbucket.org/vitorrios/node-example)