Armazenamento em cache de dependências para ganhar velocidade

Você já percebeu que seu fluxo de trabalho baixa as mesmas dependências novamente a cada execução? Isso torna tudo mais lento!

O cache no GitHub Actions permite armazenar e reutilizar arquivos de execuções anteriores. Isso acelera significativamente as execuções posteriores do fluxo de trabalho.

O GitHub fornece uma ação especial chamada actions/cache@v3. Essa ação foi projetada para salvar e restaurar arquivos, tornando seus fluxos de trabalho mais rápidos.

Ela é inteligente: verifica se o cache já existe antes de tentar restaurá-lo e o salva caso não exista.

Dois parâmetros fundamentais de actions/cache são key e path:

• key: uma cadeia de caracteres exclusiva que identifica seu cache. Se um cache com essa chave for encontrado, ele será restaurado.
• path: os caminhos de arquivos ou diretórios que você deseja armazenar em cache. Isso informa à ação *o que* salvar ou restaurar.

A chave geralmente inclui um hash dos arquivos de dependências para garantir que o cache seja invalidado quando as dependências mudarem.

Vamos armazenar node_modules em cache em um projeto de Node.js. Usaremos hashFiles para criar uma chave dinâmica com base em package-lock.json.

Experimente executar este simples trecho de fluxo de trabalho:

E se sua key exata não corresponder a nenhum cache? É aí que as restore-keys são úteis!

restore-keys fornecem uma lista de chaves alternativas para pesquisa. Se a chave principal (por exemplo, npm-${{ hashFiles(...) }}) não encontrar correspondência, o GitHub Actions tentará localizar um cache usando as restore-keys na ordem apresentada.

No nosso exemplo, npm- tenta localizar qualquer cache que comece com "npm-", o que é útil quando apenas versões secundárias das dependências foram alteradas.

O armazenamento em cache não serve apenas para Node.js! Você pode aplicar o mesmo princípio a outras linguagens, como Python. Aqui, armazenamos em cache o ambiente virtual do Python e o cache do pip.

A chave usa hashFiles('requirements.txt'), e o caminho aponta para o ambiente virtual e o diretório de cache do pip.

Um cache só é útil se estiver suficientemente atualizado. Se suas dependências mudarem, seu cache também deverá mudar!

O cache é invalidado automaticamente se sua key principal (por exemplo, npm-${{ hashFiles('package-lock.json') }}) mudar. Se package-lock.json for atualizado, o hash mudará e um novo cache será criado.

Você também pode forçar a recriação de um cache alterando manualmente a chave (por exemplo, adicionando um sufixo de versão, como npm-v2-${{ hashFiles(...) }}).

É importante saber como o cache funciona nos bastidores:

• Escopo: os caches têm escopo por repositório e por ramificação. Um cache na ramificação main não será usado em uma ramificação de recurso, a menos que você configure explicitamente lookup-path.
• Limite de tamanho: cada cache pode ter até 10 GB.
• Retenção: os caches são mantidos por 7 dias após o último acesso. Caches antigos e não utilizados são removidos automaticamente.

Para aproveitar o cache ao máximo:

• Use hashFiles: sempre vincule sua chave de cache aos arquivos de manifesto das dependências (por exemplo, package-lock.json e requirements.txt).
• Seja específico com path: armazene em cache apenas o que for necessário (por exemplo, node_modules e ~/.cache/pip).
• Use restore-keys: forneça alternativas para aumentar a taxa de acertos do cache.
• Evite armazenar dados voláteis em cache: não armazene arquivos que mudam com frequência ou que sejam muito grandes e exclusivos de cada execução (por exemplo, artefatos de compilação destinados à implantação).

Você tem um projeto Java que usa Maven. Suas dependências estão definidas em pom.xml, e o Maven normalmente armazena JARs baixados em ~/.m2/repository.

Qual configuração de cache garante melhor que as dependências do Maven sejam armazenadas em cache e invalidadas corretamente quando pom.xml for alterado?

Ótimo trabalho! Você aprendeu a implementar o armazenamento em cache no GitHub Actions para acelerar significativamente seus fluxos de CI/CD.

• A ação actions/cache é sua ferramenta.
• Use key e path para definir o que e como armazenar em cache.
• hashFiles cria chaves dinâmicas para uma invalidação inteligente.
• restore-keys fornece alternativas valiosas.

Ao armazenar dependências em cache de forma inteligente, você economiza tempo de compilação e recursos computacionais, tornando seus processos mais eficientes!