Armazenamento em cache de dependências para ganhar velocidade
Implemente o armazenamento em cache para acelerar significativamente a execução dos fluxos de trabalho, reutilizando dependências geradas e resultados de compilação.
Armazenamento em cache de dependências para ganhar velocidade é uma aula grátis de CI/CD with GitHub Actions & DevOps Pipelines no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de CI/CD with GitHub Actions & DevOps Pipelines, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de CI/CD with GitHub Actions & DevOps Pipelines inclui 4 aulas no total.
Acelere os fluxos de trabalho com o cache
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.
Conheça a ação de cache
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.
Chave e caminho do cache
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.
Armazenando dependências de Node.js em cache
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:
name: Node.js CI with Cache
on: [push]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Cache Node.js modules
uses: actions/cache@v3
with:
path: node_modules
key: npm-${{ hashFiles('package-lock.json') }}
restore-keys: |
npm-
- name: Install dependencies
run: npm ci
- name: Run tests
run: npm testAlternativa com chaves de restauração
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.
Armazenando dependências de Python em cache
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.
name: Python CI with Cache
on: [push]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Set up Python
uses: actions/setup-python@v5
with:
python-version: '3.x'
- name: Cache Python dependencies
uses: actions/cache@v3
with:
path: |
~/.cache/pip
.venv
key: pip-${{ hashFiles('requirements.txt') }}
restore-keys: |
pip-
- name: Install dependencies
run: |
python -m venv .venv
.venv/bin/pip install -r requirements.txt
- name: Run tests
run: .venv/bin/python -m unittest discoverQuando invalidar o cache
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(...) }}).
Escopo e limites do cache
É 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
mainnão será usado em uma ramificação de recurso, a menos que você configure explicitamentelookup-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.
Práticas inteligentes de armazenamento em cache
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.jsonerequirements.txt). - Seja específico com
path: armazene em cache apenas o que for necessário (por exemplo,node_modulese~/.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).
Desafio da chave de cache
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?
Recapitulação: cache para ganhar velocidade!
Ó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
keyepathpara definir o que e como armazenar em cache. hashFilescria chaves dinâmicas para uma invalidação inteligente.restore-keysfornece 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!
Perguntas Frequentes
A aula “Armazenamento em cache de dependências para ganhar velocidade” é grátis?
Sim — o texto completo de “Armazenamento em cache de dependências para ganhar velocidade” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de CI/CD with GitHub Actions & DevOps Pipelines, atualize para CoddyKit PRO. O curso de CI/CD with GitHub Actions & DevOps Pipelines inclui 4 aulas no total.
O que vou aprender em “Armazenamento em cache de dependências para ganhar velocidade”?
Implemente o armazenamento em cache para acelerar significativamente a execução dos fluxos de trabalho, reutilizando dependências geradas e resultados de compilação. Você pratica CI/CD with GitHub Actions & DevOps Pipelines com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar CI/CD with GitHub Actions & DevOps Pipelines?
Nenhuma experiência prévia é necessária. CI/CD with GitHub Actions & DevOps Pipelines no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.
Quanto tempo leva a aula “Armazenamento em cache de dependências para ganhar velocidade”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de CI/CD with GitHub Actions & DevOps Pipelines?
Sim. Cada aula de CI/CD with GitHub Actions & DevOps Pipelines inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Compilações em matriz para vários ambientes
- Armazenamento em cache de dependências para ganhar velocidade
- Fluxos de trabalho e ações reutilizáveis
- Execução condicional e dependências de tarefas